From bc3f5e43d9288ccc5d003523e943eb3a29abc64b Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Wed, 27 Dec 2017 19:38:11 +0100 Subject: [PATCH 01/22] Added swig generated wrappers (aruco_wrap.cxx, aruco_wrap.h) Added MANIFEST.in and LICENSE.txt for PyPi/pip support Package is now available in pip (closes #14) --- .gitignore | 1 - LICENSE.txt | 26 + MANIFEST.in | 3 + README.md | 6 + aruco_wrap.cxx | 29553 +++++++++++++++++++++++++++++++++++++++++++++++ aruco_wrap.h | 18 + setup.py | 8 +- 7 files changed, 29612 insertions(+), 3 deletions(-) create mode 100644 LICENSE.txt create mode 100644 MANIFEST.in create mode 100644 aruco_wrap.cxx create mode 100644 aruco_wrap.h diff --git a/.gitignore b/.gitignore index 6a303f8..07b4242 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ # generated files aruco.py -aruco_wrap.* # Byte-compiled / optimized / DLL files diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..c0db278 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,26 @@ + +Copyright 2011 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. \ No newline at end of file diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..daca31f --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,3 @@ +recursive-include aruco *.h +include aruco_wrap.cxx +include aruco_wrap.h \ No newline at end of file diff --git a/README.md b/README.md index b61eb3c..fd91b88 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,12 @@ Works with OpenCV Python module cv2 resp. numpy array data types. Tested on Linux Mint 18.2 x86_64, OpenCV 3.3.1, ArUco 3.0.4, Python 2.7.6 and NumPy 1.10.4 +Installation via pip +-------------------- +1. Install / compile [OpenCV](http://opencv.org/) >= 3.3.1 with Python2 support +2. download, compile and install ArUco 3 : http://www.uco.es/investiga/grupos/ava/node/26, +3. run `sudo -H pip install aruco` + Installation Python2 -------------------- diff --git a/aruco_wrap.cxx b/aruco_wrap.cxx new file mode 100644 index 0000000..8245f6f --- /dev/null +++ b/aruco_wrap.cxx @@ -0,0 +1,29553 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 3.0.8 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGPYTHON +#define SWIGPYTHON +#endif + +#define SWIG_DIRECTORS +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + + +#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) +/* Use debug wrappers with the Python release dll */ +# undef _DEBUG +# include +# define _DEBUG +#else +# include +#endif + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = ((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Warning: This function will allocate a new string in Python 3, + * so please call SWIG_Python_str_DelForPy3(x) to free the space. + */ +SWIGINTERN char* +SWIG_Python_str_AsChar(PyObject *str) +{ +#if PY_VERSION_HEX >= 0x03000000 + char *cstr; + char *newstr; + Py_ssize_t len; + str = PyUnicode_AsUTF8String(str); + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char *) malloc(len+1); + memcpy(newstr, cstr, len+1); + Py_XDECREF(str); + return newstr; +#else + return PyString_AsString(str); +#endif +} + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#else +# define SWIG_Python_str_DelForPy3(x) +#endif + + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +/* Add PyOS_snprintf for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) +# define PyOS_snprintf _snprintf +# else +# define PyOS_snprintf snprintf +# endif +#endif + +/* A crude PyString_FromFormat implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 + +#ifndef SWIG_PYBUFFER_SIZE +# define SWIG_PYBUFFER_SIZE 1024 +#endif + +static PyObject * +PyString_FromFormat(const char *fmt, ...) { + va_list ap; + char buf[SWIG_PYBUFFER_SIZE * 2]; + int res; + va_start(ap, fmt); + res = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); +} +#endif + +/* Add PyObject_Del for old Pythons */ +#if PY_VERSION_HEX < 0x01060000 +# define PyObject_Del(op) PyMem_DEL((op)) +#endif +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +/* A crude PyExc_StopIteration exception for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +# ifndef PyExc_StopIteration +# define PyExc_StopIteration PyExc_RuntimeError +# endif +# ifndef PyObject_GenericGetAttr +# define PyObject_GenericGetAttr 0 +# endif +#endif + +/* Py_NotImplemented is defined in 2.1 and up. */ +#if PY_VERSION_HEX < 0x02010000 +# ifndef Py_NotImplemented +# define Py_NotImplemented PyExc_RuntimeError +# endif +#endif + +/* A crude PyString_AsStringAndSize implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02010000 +# ifndef PyString_AsStringAndSize +# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} +# endif +#endif + +/* PySequence_Size for old Pythons */ +#if PY_VERSION_HEX < 0x02000000 +# ifndef PySequence_Size +# define PySequence_Size PySequence_Length +# endif +#endif + +/* PyBool_FromLong for old Pythons */ +#if PY_VERSION_HEX < 0x02030000 +static +PyObject *PyBool_FromLong(long ok) +{ + PyObject *result = ok ? Py_True : Py_False; + Py_INCREF(result); + return result; +} +#endif + +/* Py_ssize_t for old Pythons */ +/* This code is as recommended by: */ +/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ +#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +typedef int Py_ssize_t; +# define PY_SSIZE_T_MAX INT_MAX +# define PY_SSIZE_T_MIN INT_MIN +typedef inquiry lenfunc; +typedef intargfunc ssizeargfunc; +typedef intintargfunc ssizessizeargfunc; +typedef intobjargproc ssizeobjargproc; +typedef intintobjargproc ssizessizeobjargproc; +typedef getreadbufferproc readbufferproc; +typedef getwritebufferproc writebufferproc; +typedef getsegcountproc segcountproc; +typedef getcharbufferproc charbufferproc; +static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) +{ + long result = 0; + PyObject *i = PyNumber_Int(x); + if (i) { + result = PyInt_AsLong(i); + Py_DECREF(i); + } + return result; +} +#endif + +#if PY_VERSION_HEX < 0x02050000 +#define PyInt_FromSize_t(x) PyInt_FromLong((long)x) +#endif + +#if PY_VERSION_HEX < 0x02040000 +#define Py_VISIT(op) \ + do { \ + if (op) { \ + int vret = visit((op), arg); \ + if (vret) \ + return vret; \ + } \ + } while (0) +#endif + +#if PY_VERSION_HEX < 0x02030000 +typedef struct { + PyTypeObject type; + PyNumberMethods as_number; + PyMappingMethods as_mapping; + PySequenceMethods as_sequence; + PyBufferProcs as_buffer; + PyObject *name, *slots; +} PyHeapTypeObject; +#endif + +#if PY_VERSION_HEX < 0x02030000 +typedef destructor freefunc; +#endif + +#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ + (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ + (PY_MAJOR_VERSION > 3)) +# define SWIGPY_USE_CAPSULE +# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) +#endif + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); + if (value) { + char *tmp; + PyObject *old_str = PyObject_Str(value); + PyErr_Clear(); + Py_XINCREF(type); + + PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ +# define SWIG_PYTHON_USE_GIL +# endif +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + + +/* ----------------------------------------------------------------------------- + * Wrapper of PyInstanceMethod_New() used in Python 3 + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ +#if PY_VERSION_HEX >= 0x03000000 +SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) +{ + return PyInstanceMethod_New(func); +} +#else +SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) +{ + return NULL; +} +#endif + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { +#if PY_VERSION_HEX < 0x02030000 + PyDict_SetItemString(d, (char *)name, obj); +#else + PyDict_SetItemString(d, name, obj); +#endif + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { +#if PY_VERSION_HEX < 0x02030000 + PyDict_SetItemString(d, (char *)name, obj); +#else + PyDict_SetItemString(d, name, obj); +#endif + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { +#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +#else + PyObject* o2; + PyObject* o3; + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyTuple_Check(result)) { + o2 = result; + result = PyTuple_New(1); + PyTuple_SET_ITEM(result, 0, o2); + } + o3 = PyTuple_New(1); + PyTuple_SET_ITEM(o3, 0, obj); + o2 = result; + result = PySequence_Concat(o2, o3); + Py_DECREF(o2); + Py_DECREF(o3); + } + return result; +#endif +} + +/* Unpack the argument tuple */ + +SWIGINTERN Py_ssize_t +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + Py_ssize_t i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + Py_ssize_t i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#if PY_VERSION_HEX >= 0x02020000 +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); +#else +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); +#endif + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* How to access Py_None */ +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# ifndef SWIG_PYTHON_NO_BUILD_NONE +# ifndef SWIG_PYTHON_BUILD_NONE +# define SWIG_PYTHON_BUILD_NONE +# endif +# endif +#endif + +#ifdef SWIG_PYTHON_BUILD_NONE +# ifdef Py_None +# undef Py_None +# define Py_None SWIG_Py_None() +# endif +SWIGRUNTIMEINLINE PyObject * +_SWIG_Py_None(void) +{ + PyObject *none = Py_BuildValue((char*)""); + Py_DECREF(none); + return none; +} +SWIGRUNTIME PyObject * +SWIG_Py_None(void) +{ + static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); + return none; +} +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + return data ? data->implicitconv : 0; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { +#if (PY_VERSION_HEX < 0x02020000) + data->newraw = 0; +#else + data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); +#endif + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); +#ifdef METH_O + data->delargs = !(flags & (METH_O)); +#else + data->delargs = 0; +#endif + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + + +#ifdef SWIGPYTHON_BUILTIN + +SWIGRUNTIME PyObject * +SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + + if (!sobj->dict) + sobj->dict = PyDict_New(); + + Py_INCREF(sobj->dict); + return sobj->dict; +} + +#endif + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { + PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +#ifdef METH_NOARGS +SwigPyObject_repr(SwigPyObject *v) +#else +SwigPyObject_repr(SwigPyObject *v, PyObject *args) +#endif +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (v->next) { +# ifdef METH_NOARGS + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); +# else + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); +# endif +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } + return repr; +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res; + if( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { +#ifdef SWIGPYTHON_BUILTIN + PyTypeObject *target_tp = SwigPyObject_type(); + if (PyType_IsSubtype(op->ob_type, target_tp)) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); +#else + return (Py_TYPE(op) == SwigPyObject_type()) + || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + + /* PyObject_CallFunction() has the potential to silently drop + the active active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *val = NULL, *type = NULL, *tb = NULL; + PyErr_Fetch(&val, &type, &tb); + + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if (!res) + PyErr_WriteUnraisable(destroy); + + PyErr_Restore(val, type, tb); + + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; +#ifndef METH_O + PyObject *tmp = 0; + if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; + next = tmp; +#endif + if (!SwigPyObject_Check(next)) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +#ifdef METH_NOARGS +SwigPyObject_next(PyObject* v) +#else +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +SwigPyObject_disown(PyObject *v) +#else +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +SwigPyObject_acquire(PyObject *v) +#else +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; +#if (PY_VERSION_HEX < 0x02020000) + if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) +#elif (PY_VERSION_HEX < 0x02050000) + if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) +#else + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) +#endif + { + return NULL; + } + else + { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { +#ifdef METH_NOARGS + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v); + } else { + SwigPyObject_disown(v); + } +#else + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v,args); + } else { + SwigPyObject_disown(v,args); + } +#endif + } + return obj; + } +} + +#ifdef METH_O +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, + {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"}, + {0, 0, 0, 0} +}; +#else +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, + {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, + {0, 0, 0, 0} +}; +#endif + +#if PY_VERSION_HEX < 0x02020000 +SWIGINTERN PyObject * +SwigPyObject_getattr(SwigPyObject *sobj,char *name) +{ + return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); +} +#endif + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ +#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ +#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ + 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { + /* PyObject header changed in Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + (char *)"SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + 0, /* tp_print */ +#if PY_VERSION_HEX < 0x02020000 + (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ +#else + (getattrfunc)0, /* tp_getattr */ +#endif + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#if PY_VERSION_HEX >= 0x02060000 + 0, /* tp_version_tag */ +#endif +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ +#if PY_VERSION_HEX >= 0x02050000 + 0, /* tp_prev */ +#endif + 0 /* tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; +#if PY_VERSION_HEX < 0x02020000 + swigpyobject_type.ob_type = &PyType_Type; +#else + if (PyType_Ready(&swigpyobject_type) < 0) + return NULL; +#endif + } + return &swigpyobject_type; +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME int +SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +{ + char result[SWIG_BUFFER_SIZE]; + fputs("pack, v->size, 0, sizeof(result))) { + fputs("at ", fp); + fputs(result, fp); + } + fputs(v->ty->name,fp); + fputs(">", fp); + return 0; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) + || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { + /* PyObject header changed in Python 3 */ +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + (char *)"SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + (printfunc)SwigPyPacked_print, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#if PY_VERSION_HEX >= 0x02060000 + 0, /* tp_version_tag */ +#endif +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ +#if PY_VERSION_HEX >= 0x02050000 + 0, /* tp_prev */ +#endif + 0 /* tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; +#if PY_VERSION_HEX < 0x02020000 + swigpypacked_type.ob_type = &PyType_Type; +#else + if (PyType_Ready(&swigpypacked_type) < 0) + return NULL; +#endif + } + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIMEINLINE PyObject * +_SWIG_This(void) +{ + return SWIG_Python_str_FromChar("this"); +} + +static PyObject *swig_this = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (swig_this == NULL) + swig_this = _SWIG_This(); + return swig_this; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None && !implicit_conv) { + if (ptr) + *ptr = 0; + return SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + res = SWIG_OK; + } else { + if (implicit_conv) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + } + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) + return SWIG_ERROR; + if (ty) { + swig_cast_info *tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + } else { + *ptr = vptr; + } + return SWIG_OK; + } +} + +/* Convert a packed value value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ +#if (PY_VERSION_HEX >= 0x02020000) + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); + if (inst) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +#else +#if (PY_VERSION_HEX >= 0x02010000) + PyObject *inst = 0; + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } + return (PyObject *) inst; +#else + PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); + if (inst == NULL) { + return NULL; + } + inst->in_class = (PyClassObject *)data->newargs; + Py_INCREF(inst->in_class); + inst->in_dict = PyDict_New(); + if (inst->in_dict == NULL) { + Py_DECREF(inst); + return NULL; + } +#ifdef Py_TPFLAGS_HAVE_WEAKREFS + inst->in_weakreflist = NULL; +#endif +#ifdef Py_TPFLAGS_GC + PyObject_GC_Init(inst); +#endif + PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); + return (PyObject *) inst; +#endif +#endif +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, (char*)"__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { + PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else +# ifdef SWIGPY_USE_CAPSULE + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); +# else + type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); +# endif + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +#if PY_MAJOR_VERSION < 2 +/* PyModule_AddObject function was introduced in Python 2.0. The following function + is copied out of Python/modsupport.c in python version 2.3.4 */ +SWIGINTERN int +PyModule_AddObject(PyObject *m, char *name, PyObject *o) +{ + PyObject *dict; + if (!PyModule_Check(m)) { + PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); + return SWIG_ERROR; + } + if (!o) { + PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); + return SWIG_ERROR; + } + + dict = PyModule_GetDict(m); + if (dict == NULL) { + /* Internal error -- modules must have a dict! */ + PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", + PyModule_GetName(m)); + return SWIG_ERROR; + } + if (PyDict_SetItemString(dict, name, o)) + return SWIG_ERROR; + Py_DECREF(o); + return SWIG_OK; +} +#endif + +SWIGRUNTIME void +#ifdef SWIGPY_USE_CAPSULE +SWIG_Python_DestroyModule(PyObject *obj) +#else +SWIG_Python_DestroyModule(void *vptr) +#endif +{ +#ifdef SWIGPY_USE_CAPSULE + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); +#else + swig_module_info *swig_module = (swig_module_info *) vptr; +#endif + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + swig_this = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif +#ifdef SWIGPY_USE_CAPSULE + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +#else + PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +#endif +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { +#ifdef SWIGPY_USE_CAPSULE + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); +#else + descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); +#endif + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { +#ifdef SWIGPY_USE_CAPSULE + obj = PyCapsule_New((void*) descriptor, NULL, NULL); +#else + obj = PyCObject_FromVoidPtr(descriptor, NULL); +#endif + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + char *tmp; + PyObject *old_str = PyObject_Str(value); + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); + } else { + PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +#if SWIG_POINTER_EXCEPTION + if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } +#endif + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res = -1; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) < 0) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Python proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ +#define SWIG_DIRECTOR_PYTHON_HEADER_ + +#include +#include +#include +#include +#include + + +/* + Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual + table', and avoid multiple GetAttr calls to retrieve the python + methods. +*/ + +#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE +#ifndef SWIG_PYTHON_DIRECTOR_VTABLE +#define SWIG_PYTHON_DIRECTOR_VTABLE +#endif +#endif + + + +/* + Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the + Undefined Exception Handler provided by swig. +*/ +#ifndef SWIG_DIRECTOR_NO_UEH +#ifndef SWIG_DIRECTOR_UEH +#define SWIG_DIRECTOR_UEH +#endif +#endif + + +/* + Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the + native C++ RTTI and dynamic_cast<>. But be aware that directors + could stop working when using this option. +*/ +#ifdef SWIG_DIRECTOR_NORTTI +/* + When we don't use the native C++ RTTI, we implement a minimal one + only for Directors. +*/ +# ifndef SWIG_DIRECTOR_RTDIR +# define SWIG_DIRECTOR_RTDIR + +namespace Swig { + class Director; + SWIGINTERN std::map& get_rtdir_map() { + static std::map rtdir_map; + return rtdir_map; + } + + SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { + get_rtdir_map()[vptr] = rtdir; + } + + SWIGINTERNINLINE Director *get_rtdir(void *vptr) { + std::map::const_iterator pos = get_rtdir_map().find(vptr); + Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; + return rtdir; + } +} +# endif /* SWIG_DIRECTOR_RTDIR */ + +# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) + +#else + +# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) + +#endif /* SWIG_DIRECTOR_NORTTI */ + +extern "C" { + struct swig_type_info; +} + +namespace Swig { + + /* memory handler */ + struct GCItem { + virtual ~GCItem() {} + + virtual int get_own() const { + return 0; + } + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem * operator->() const { + return _item; + } + + private: + GCItem *_item; + }; + + struct GCItem_Object : GCItem { + GCItem_Object(int own) : _own(own) { + } + + virtual ~GCItem_Object() { + } + + int get_own() const { + return _own; + } + + private: + int _own; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; + + template + struct GCArray_T : GCItem { + GCArray_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCArray_T() { + delete[] _ptr; + } + + private: + Type *_ptr; + }; + + /* base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + public: + DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (msg[0]) { + swig_msg += " "; + swig_msg += msg; + } + if (!PyErr_Occurred()) { + PyErr_SetString(error, what()); + } + SWIG_PYTHON_THREAD_END_BLOCK; + } + + virtual ~DirectorException() throw() { + } + + /* Deprecated, use what() instead */ + const char *getMessage() const { + return what(); + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorException(error, msg); + } + + static void raise(const char *msg) { + raise(PyExc_RuntimeError, msg); + } + }; + + /* unknown exception handler */ + class UnknownExceptionHandler { +#ifdef SWIG_DIRECTOR_UEH + static void handler() { + try { + throw; + } catch (DirectorException& e) { + std::cerr << "SWIG Director exception caught:" << std::endl + << e.what() << std::endl; + } catch (std::exception& e) { + std::cerr << "std::exception caught: "<< e.what() << std::endl; + } catch (...) { + std::cerr << "Unknown exception caught." << std::endl; + } + + std::cerr << std::endl + << "Python interpreter traceback:" << std::endl; + PyErr_Print(); + std::cerr << std::endl; + + std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl + << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl + << std::endl + << "Exception is being re-thrown, program will likely abort/terminate." << std::endl; + throw; + } + + public: + + std::unexpected_handler old; + UnknownExceptionHandler(std::unexpected_handler nh = handler) { + old = std::set_unexpected(nh); + } + + ~UnknownExceptionHandler() { + std::set_unexpected(old); + } +#endif + }; + + /* type mismatch in the return value from a python method call */ + class DirectorTypeMismatchException : public DirectorException { + public: + DirectorTypeMismatchException(PyObject *error, const char *msg="") + : DirectorException(error, "SWIG director type mismatch", msg) { + } + + DirectorTypeMismatchException(const char *msg="") + : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorTypeMismatchException(error, msg); + } + + static void raise(const char *msg) { + throw DirectorTypeMismatchException(msg); + } + }; + + /* any python exception that occurs during a director method call */ + class DirectorMethodException : public DirectorException { + public: + DirectorMethodException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { + } + + static void raise(const char *msg) { + throw DirectorMethodException(msg); + } + }; + + /* attempt to call a pure virtual method via a director method */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { + } + + static void raise(const char *msg) { + throw DirectorPureVirtualException(msg); + } + }; + + +#if defined(SWIG_PYTHON_THREADS) +/* __THREAD__ is the old macro to activate some thread support */ +# if !defined(__THREAD__) +# define __THREAD__ 1 +# endif +#endif + +#ifdef __THREAD__ +# include "pythread.h" + class Guard { + PyThread_type_lock &mutex_; + + public: + Guard(PyThread_type_lock & mutex) : mutex_(mutex) { + PyThread_acquire_lock(mutex_, WAIT_LOCK); + } + + ~Guard() { + PyThread_release_lock(mutex_); + } + }; +# define SWIG_GUARD(mutex) Guard _guard(mutex) +#else +# define SWIG_GUARD(mutex) +#endif + + /* director base class */ + class Director { + private: + /* pointer to the wrapped python object */ + PyObject *swig_self; + /* flag indicating whether the object is owned by python or c++ */ + mutable bool swig_disown_flag; + + /* decrement the reference count of the wrapped python object */ + void swig_decref() const { + if (swig_disown_flag) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_DECREF(swig_self); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + public: + /* wrap a python object. */ + Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { + } + + /* discard our reference at destruction */ + virtual ~Director() { + swig_decref(); + } + + /* return a pointer to the wrapped python object */ + PyObject *swig_get_self() const { + return swig_self; + } + + /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); + } + } + + /* increase the reference count of the wrapped python object */ + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); + } + } + + /* methods to implement pseudo protected director members */ + virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { + return true; + } + + virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { + } + + /* ownership management */ + private: + typedef std::map swig_ownership_map; + mutable swig_ownership_map swig_owner; +#ifdef __THREAD__ + static PyThread_type_lock swig_mutex_own; +#endif + + public: + template + void swig_acquire_ownership_array(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCArray_T(vptr); + } + } + + template + void swig_acquire_ownership(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_T(vptr); + } + } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_Object(own); + } + } + + int swig_release_ownership(void *vptr) const { + int own = 0; + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_ownership_map::iterator iter = swig_owner.find(vptr); + if (iter != swig_owner.end()) { + own = iter->second->get_own(); + swig_owner.erase(iter); + } + } + return own; + } + + template + static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { + SwigPyObject *sobj = (SwigPyObject *)pyobj; + sobj->own = 0; + Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); + if (d) + d->swig_disown(); + return PyWeakref_NewProxy(pyobj, NULL); + } + }; + +#ifdef __THREAD__ + PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock(); +#endif +} + +#endif + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_Marker swig_types[0] +#define SWIGTYPE_p_allocator_type swig_types[1] +#define SWIGTYPE_p_aruco__CameraParameters swig_types[2] +#define SWIGTYPE_p_aruco__CvDrawingUtils swig_types[3] +#define SWIGTYPE_p_aruco__Debug swig_types[4] +#define SWIGTYPE_p_aruco__Dictionary swig_types[5] +#define SWIGTYPE_p_aruco__DictionaryBased swig_types[6] +#define SWIGTYPE_p_aruco__Marker swig_types[7] +#define SWIGTYPE_p_aruco__Marker3DInfo swig_types[8] +#define SWIGTYPE_p_aruco__MarkerCandidate swig_types[9] +#define SWIGTYPE_p_aruco__MarkerDetector swig_types[10] +#define SWIGTYPE_p_aruco__MarkerLabeler swig_types[11] +#define SWIGTYPE_p_aruco__MarkerMap swig_types[12] +#define SWIGTYPE_p_aruco__MarkerMapPoseTracker swig_types[13] +#define SWIGTYPE_p_aruco__MarkerPoseTracker swig_types[14] +#define SWIGTYPE_p_aruco__Params swig_types[15] +#define SWIGTYPE_p_aruco__SVMMarkers swig_types[16] +#define SWIGTYPE_p_aruco__ScopeTimer swig_types[17] +#define SWIGTYPE_p_aruco__ScopedTimerEvents swig_types[18] +#define SWIGTYPE_p_aruco__Timer swig_types[19] +#define SWIGTYPE_p_char swig_types[20] +#define SWIGTYPE_p_cv__Point2f swig_types[21] +#define SWIGTYPE_p_cv__Point3f swig_types[22] +#define SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t swig_types[23] +#define SWIGTYPE_p_cv__Size swig_types[24] +#define SWIGTYPE_p_difference_type swig_types[25] +#define SWIGTYPE_p_double swig_types[26] +#define SWIGTYPE_p_int swig_types[27] +#define SWIGTYPE_p_p_PyObject swig_types[28] +#define SWIGTYPE_p_size_type swig_types[29] +#define SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t swig_types[30] +#define SWIGTYPE_p_std__allocatorT_aruco__Marker_t swig_types[31] +#define SWIGTYPE_p_std__allocatorT_cv__Point2f_t swig_types[32] +#define SWIGTYPE_p_std__allocatorT_int_t swig_types[33] +#define SWIGTYPE_p_std__chrono__high_resolution_clock__time_point swig_types[34] +#define SWIGTYPE_p_std__invalid_argument swig_types[35] +#define SWIGTYPE_p_std__istream swig_types[36] +#define SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t swig_types[37] +#define SWIGTYPE_p_std__ostream swig_types[38] +#define SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t swig_types[39] +#define SWIGTYPE_p_std__string swig_types[40] +#define SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t swig_types[41] +#define SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t swig_types[42] +#define SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t swig_types[43] +#define SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t swig_types[44] +#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[45] +#define SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t swig_types[46] +#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[47] +#define SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t swig_types[48] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[49] +#define SWIGTYPE_p_uint32_t swig_types[50] +#define SWIGTYPE_p_uint64_t swig_types[51] +#define SWIGTYPE_p_value_type swig_types[52] +#define SWIGTYPE_p_vectorT_aruco__Marker_t swig_types[53] +#define SWIGTYPE_p_vectorT_cv__Point3f_t swig_types[54] +#define SWIGTYPE_p_vectorT_cv__Point_t swig_types[55] +#define SWIGTYPE_p_vectorT_int_t swig_types[56] +static swig_type_info *swig_types[58]; +static swig_module_info swig_module = {swig_types, 57, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#if (PY_VERSION_HEX <= 0x02000000) +# if !defined(SWIG_PYTHON_CLASSIC) +# error "This python version requires swig to be run with the '-classic' option" +# endif +#endif + +/*----------------------------------------------- + @(target):= _aruco.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__aruco + +#else +# define SWIG_init init_aruco + +#endif +#define SWIG_name "_aruco" + +#define SWIGVERSION 0x030008 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include + + +#include + +#if PY_VERSION_HEX >= 0x03020000 +# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj)) +#else +# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj)) +#endif + + +#include + + +#if defined(__GNUC__) +# if __GNUC__ == 2 && __GNUC_MINOR <= 96 +# define SWIG_STD_NOMODERN_STL +# endif +#endif + + +#include + + +namespace swig { + struct stop_iteration { + }; + + struct SwigPyIterator { + private: + SwigPtr_PyObject _seq; + + protected: + SwigPyIterator(PyObject *seq) : _seq(seq) + { + } + + public: + virtual ~SwigPyIterator() {} + + // Access iterator method, required by Python + virtual PyObject *value() const = 0; + + // Forward iterator method, required by Python + virtual SwigPyIterator *incr(size_t n = 1) = 0; + + // Backward iterator method, very common in C++, but not required in Python + virtual SwigPyIterator *decr(size_t /*n*/ = 1) + { + throw stop_iteration(); + } + + // Random access iterator methods, but not required in Python + virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const + { + throw std::invalid_argument("operation not supported"); + } + + virtual bool equal (const SwigPyIterator &/*x*/) const + { + throw std::invalid_argument("operation not supported"); + } + + // C++ common/needed methods + virtual SwigPyIterator *copy() const = 0; + + PyObject *next() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads + PyObject *obj = value(); + incr(); + SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads + return obj; + } + + /* Make an alias for Python 3.x */ + PyObject *__next__() + { + return next(); + } + + PyObject *previous() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads + decr(); + PyObject *obj = value(); + SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads + return obj; + } + + SwigPyIterator *advance(ptrdiff_t n) + { + return (n > 0) ? incr(n) : decr(-n); + } + + bool operator == (const SwigPyIterator& x) const + { + return equal(x); + } + + bool operator != (const SwigPyIterator& x) const + { + return ! operator==(x); + } + + SwigPyIterator& operator += (ptrdiff_t n) + { + return *advance(n); + } + + SwigPyIterator& operator -= (ptrdiff_t n) + { + return *advance(-n); + } + + SwigPyIterator* operator + (ptrdiff_t n) const + { + return copy()->advance(n); + } + + SwigPyIterator* operator - (ptrdiff_t n) const + { + return copy()->advance(-n); + } + + ptrdiff_t operator - (const SwigPyIterator& x) const + { + return x.distance(*this); + } + + static swig_type_info* descriptor() { + static int init = 0; + static swig_type_info* desc = 0; + if (!init) { + desc = SWIG_TypeQuery("swig::SwigPyIterator *"); + init = 1; + } + return desc; + } + }; + +#if defined(SWIGPYTHON_BUILTIN) + inline PyObject* make_output_iterator_builtin (PyObject *pyself) + { + Py_INCREF(pyself); + return pyself; + } +#endif +} + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + long v = PyInt_AsLong(obj); + if (v >= 0) { + if (val) *val = v; + return SWIG_OK; + } else { + return SWIG_OverflowError; + } + } else +#endif + if (PyLong_Check(obj)) { + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { + if (val) *val = (unsigned long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERNINLINE int +SWIG_AsVal_size_t (PyObject * obj, size_t *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); + return res; +} + + + #define SWIG_From_long PyLong_FromLong + + +SWIGINTERNINLINE PyObject * +SWIG_From_ptrdiff_t (ptrdiff_t value) +{ + return SWIG_From_long (static_cast< long >(value)); +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERNINLINE int +SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val) +{ + long v; + int res = SWIG_AsVal_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); + return res; +} + + +#include + + +#include + + + #define SWIG_FILE_WITH_INIT + using namespace std; + + +namespace swig { + template + struct noconst_traits { + typedef Type noconst_type; + }; + + template + struct noconst_traits { + typedef Type noconst_type; + }; + + /* + type categories + */ + struct pointer_category { }; + struct value_category { }; + + /* + General traits that provides type_name and type_info + */ + template struct traits { }; + + template + inline const char* type_name() { + return traits::noconst_type >::type_name(); + } + + template + struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; + } + }; + + template + inline swig_type_info *type_info() { + return traits_info::type_info(); + } + + /* + Partial specialization for pointers + */ + template struct traits { + typedef pointer_category category; + static std::string make_ptr_name(const char* name) { + std::string ptrname = name; + ptrname += " *"; + return ptrname; + } + static const char* type_name() { + static std::string name = make_ptr_name(swig::type_name()); + return name.c_str(); + } + }; + + template + struct traits_as { }; + + template + struct traits_check { }; + +} + + +namespace swig { + /* + Traits that provides the from method + */ + template struct traits_from_ptr { + static PyObject *from(Type *val, int owner = 0) { + return SWIG_InternalNewPointerObj(val, type_info(), owner); + } + }; + + template struct traits_from { + static PyObject *from(const Type& val) { + return traits_from_ptr::from(new Type(val), 1); + } + }; + + template struct traits_from { + static PyObject *from(Type* val) { + return traits_from_ptr::from(val, 0); + } + }; + + template struct traits_from { + static PyObject *from(const Type* val) { + return traits_from_ptr::from(const_cast(val), 0); + } + }; + + + template + inline PyObject *from(const Type& val) { + return traits_from::from(val); + } + + template + inline PyObject *from_ptr(Type* val, int owner) { + return traits_from_ptr::from(val, owner); + } + + /* + Traits that provides the asval/as/check method + */ + template + struct traits_asptr { + static int asptr(PyObject *obj, Type **val) { + Type *p; + int res = SWIG_ConvertPtr(obj, (void**)&p, type_info(), 0); + if (SWIG_IsOK(res)) { + if (val) *val = p; + } + return res; + } + }; + + template + inline int asptr(PyObject *obj, Type **vptr) { + return traits_asptr::asptr(obj, vptr); + } + + template + struct traits_asval { + static int asval(PyObject *obj, Type *val) { + if (val) { + Type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (!SWIG_IsOK(res)) return res; + if (p) { + typedef typename noconst_traits::noconst_type noconst_type; + *(const_cast(val)) = *p; + if (SWIG_IsNewObj(res)){ + delete p; + res = SWIG_DelNewMask(res); + } + return res; + } else { + return SWIG_ERROR; + } + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template struct traits_asval { + static int asval(PyObject *obj, Type **val) { + if (val) { + typedef typename noconst_traits::noconst_type noconst_type; + noconst_type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) { + *(const_cast(val)) = p; + } + return res; + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template + inline int asval(PyObject *obj, Type *val) { + return traits_asval::asval(obj, val); + } + + template + struct traits_as { + static Type as(PyObject *obj, bool throw_error) { + Type v; + int res = asval(obj, &v); + if (!obj || !SWIG_IsOK(res)) { + if (!PyErr_Occurred()) { + ::SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + } + return v; + } + }; + + template + struct traits_as { + static Type as(PyObject *obj, bool throw_error) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res) && v) { + if (SWIG_IsNewObj(res)) { + Type r(*v); + delete v; + return r; + } else { + return *v; + } + } else { + // Uninitialized return value, no Type() constructor required. + static Type *v_def = (Type*) malloc(sizeof(Type)); + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + memset(v_def,0,sizeof(Type)); + return *v_def; + } + } + }; + + template + struct traits_as { + static Type* as(PyObject *obj, bool throw_error) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res)) { + return v; + } else { + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + return 0; + } + } + }; + + template + inline Type as(PyObject *obj, bool te = false) { + return traits_as::category>::as(obj, te); + } + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + inline bool check(PyObject *obj) { + return traits_check::category>::check(obj); + } +} + + +#include + +namespace std { + template <> + struct less : public binary_function + { + bool + operator()(PyObject * v, PyObject *w) const + { + bool res; + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false; + /* This may fall into a case of inconsistent + eg. ObjA > ObjX > ObjB + but ObjA < ObjB + */ + if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) ) + { + /* Objects can't be compared, this mostly occurred in Python 3.0 */ + /* Compare their ptr directly for a workaround */ + res = (v < w); + PyErr_Clear(); + } + SWIG_PYTHON_THREAD_END_BLOCK; + return res; + } + }; + + template <> + struct less : public binary_function + { + bool + operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const + { + return std::less()(v, w); + } + }; + + template <> + struct less : public binary_function + { + bool + operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const + { + return std::less()(v, w); + } + }; + +} + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return "PyObject *"; } + }; + + template <> struct traits_asval { + typedef PyObject * value_type; + static int asval(PyObject *obj, value_type *val) { + if (val) *val = obj; + return SWIG_OK; + } + }; + + template <> + struct traits_check { + static bool check(PyObject *) { + return true; + } + }; + + template <> struct traits_from { + typedef PyObject * value_type; + static PyObject *from(const value_type& val) { + Py_XINCREF(val); + return val; + } + }; + +} + +namespace swig { + template + inline size_t + check_index(Difference i, size_t size, bool insert = false) { + if ( i < 0 ) { + if ((size_t) (-i) <= size) + return (size_t) (i + size); + } else if ( (size_t) i < size ) { + return (size_t) i; + } else if (insert && ((size_t) i == size)) { + return size; + } + throw std::out_of_range("index out of range"); + } + + template + void + slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) { + if (step == 0) { + throw std::invalid_argument("slice step cannot be zero"); + } else if (step > 0) { + // Required range: 0 <= i < size, 0 <= j < size + if (i < 0) { + ii = 0; + } else if (i < (Difference)size) { + ii = i; + } else if (insert && (i >= (Difference)size)) { + ii = (Difference)size; + } + if ( j < 0 ) { + jj = 0; + } else { + jj = (j < (Difference)size) ? j : (Difference)size; + } + } else { + // Required range: -1 <= i < size-1, -1 <= j < size-1 + if (i < -1) { + ii = -1; + } else if (i < (Difference) size) { + ii = i; + } else if (i >= (Difference)(size-1)) { + ii = (Difference)(size-1); + } + if (j < -1) { + jj = -1; + } else { + jj = (j < (Difference)size ) ? j : (Difference)(size-1); + } + } + } + + template + inline typename Sequence::iterator + getpos(Sequence* self, Difference i) { + typename Sequence::iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline typename Sequence::const_iterator + cgetpos(const Sequence* self, Difference i) { + typename Sequence::const_iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline void + erase(Sequence* seq, const typename Sequence::iterator& position) { + seq->erase(position); + } + + template + inline Sequence* + getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj); + + if (step > 0) { + typename Sequence::const_iterator sb = self->begin(); + typename Sequence::const_iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + if (step == 1) { + return new Sequence(sb, se); + } else { + Sequence *sequence = new Sequence(); + typename Sequence::const_iterator it = sb; + while (it!=se) { + sequence->push_back(*it); + for (Py_ssize_t c=0; c jj) { + typename Sequence::const_reverse_iterator sb = self->rbegin(); + typename Sequence::const_reverse_iterator se = self->rbegin(); + std::advance(sb,size-ii-1); + std::advance(se,size-jj-1); + typename Sequence::const_reverse_iterator it = sb; + while (it!=se) { + sequence->push_back(*it); + for (Py_ssize_t c=0; c<-step && it!=se; ++c) + it++; + } + } + return sequence; + } + } + + template + inline void + setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj, true); + if (step > 0) { + if (jj < ii) + jj = ii; + if (step == 1) { + size_t ssize = jj - ii; + if (ssize <= is.size()) { + // expanding/staying the same size + typename Sequence::iterator sb = self->begin(); + typename InputSeq::const_iterator isit = is.begin(); + std::advance(sb,ii); + std::advance(isit, jj - ii); + self->insert(std::copy(is.begin(), isit, sb), isit, is.end()); + } else { + // shrinking + typename Sequence::iterator sb = self->begin(); + typename Sequence::iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + self->erase(sb,se); + sb = self->begin(); + std::advance(sb,ii); + self->insert(sb, is.begin(), is.end()); + } + } else { + size_t replacecount = (jj - ii + step - 1) / step; + if (is.size() != replacecount) { + char msg[1024]; + sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); + throw std::invalid_argument(msg); + } + typename Sequence::const_iterator isit = is.begin(); + typename Sequence::iterator it = self->begin(); + std::advance(it,ii); + for (size_t rc=0; rcend(); ++c) + it++; + } + } + } else { + if (jj > ii) + jj = ii; + size_t replacecount = (ii - jj - step - 1) / -step; + if (is.size() != replacecount) { + char msg[1024]; + sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); + throw std::invalid_argument(msg); + } + typename Sequence::const_iterator isit = is.begin(); + typename Sequence::reverse_iterator it = self->rbegin(); + std::advance(it,size-ii-1); + for (size_t rc=0; rcrend(); ++c) + it++; + } + } + } + + template + inline void + delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj, true); + if (step > 0) { + if (jj > ii) { + typename Sequence::iterator sb = self->begin(); + std::advance(sb,ii); + if (step == 1) { + typename Sequence::iterator se = self->begin(); + std::advance(se,jj); + self->erase(sb,se); + } else { + typename Sequence::iterator it = sb; + size_t delcount = (jj - ii + step - 1) / step; + while (delcount) { + it = self->erase(it); + for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) + it++; + delcount--; + } + } + } + } else { + if (ii > jj) { + typename Sequence::reverse_iterator sb = self->rbegin(); + std::advance(sb,size-ii-1); + typename Sequence::reverse_iterator it = sb; + size_t delcount = (ii - jj - step - 1) / -step; + while (delcount) { + it = typename Sequence::reverse_iterator(self->erase((++it).base())); + for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) + it++; + delcount--; + } + } + } + } +} + + +#if defined(__SUNPRO_CC) && defined(_RWSTD_VER) +# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL) +# define SWIG_STD_NOITERATOR_TRAITS_STL +# endif +#endif + +#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL) +#include +#else +namespace std { + template + struct iterator_traits { + typedef ptrdiff_t difference_type; + typedef typename Iterator::value_type value_type; + }; + + template + struct iterator_traits<__reverse_bi_iterator > { + typedef Distance difference_type; + typedef T value_type; + }; + + template + struct iterator_traits { + typedef T value_type; + typedef ptrdiff_t difference_type; + }; + + template + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) { + ++__first; ++__n; + } + return __n; + } +} +#endif + + +namespace swig { + template + class SwigPyIterator_T : public SwigPyIterator + { + public: + typedef OutIterator out_iterator; + typedef typename std::iterator_traits::value_type value_type; + typedef SwigPyIterator_T self_type; + + SwigPyIterator_T(out_iterator curr, PyObject *seq) + : SwigPyIterator(seq), current(curr) + { + } + + const out_iterator& get_current() const + { + return current; + } + + + bool equal (const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return (current == iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + ptrdiff_t distance(const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return std::distance(current, iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + protected: + out_iterator current; + }; + + template + struct from_oper + { + typedef const ValueType& argument_type; + typedef PyObject *result_type; + result_type operator()(argument_type v) const + { + return swig::from(v); + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorOpen_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyIteratorOpen_T self_type; + + SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq) + : SwigPyIterator_T(curr, seq) + { + } + + PyObject *value() const { + return from(static_cast(*(base::current))); + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + ++base::current; + } + return this; + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + --base::current; + } + return this; + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorClosed_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyIteratorClosed_T self_type; + + SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) + : SwigPyIterator_T(curr, seq), begin(first), end(last) + { + } + + PyObject *value() const { + if (base::current == end) { + throw stop_iteration(); + } else { + return from(static_cast(*(base::current))); + } + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + if (base::current == end) { + throw stop_iteration(); + } else { + ++base::current; + } + } + return this; + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + if (base::current == begin) { + throw stop_iteration(); + } else { + --base::current; + } + } + return this; + } + + private: + out_iterator begin; + out_iterator end; + }; + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) + { + return new SwigPyIteratorClosed_T(current, begin, end, seq); + } + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, PyObject *seq = 0) + { + return new SwigPyIteratorOpen_T(current, seq); + } + +} + + +namespace swig +{ + template + struct SwigPySequence_Ref + { + SwigPySequence_Ref(PyObject* seq, Py_ssize_t index) + : _seq(seq), _index(index) + { + } + + operator T () const + { + swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index); + try { + return swig::as(item, true); + } catch (std::exception& e) { + char msg[1024]; + sprintf(msg, "in sequence element %d ", (int)_index); + if (!PyErr_Occurred()) { + ::SWIG_Error(SWIG_TypeError, swig::type_name()); + } + SWIG_Python_AddErrorMsg(msg); + SWIG_Python_AddErrorMsg(e.what()); + throw; + } + } + + SwigPySequence_Ref& operator=(const T& v) + { + PySequence_SetItem(_seq, _index, swig::from(v)); + return *this; + } + + private: + PyObject* _seq; + Py_ssize_t _index; + }; + + template + struct SwigPySequence_ArrowProxy + { + SwigPySequence_ArrowProxy(const T& x): m_value(x) {} + const T* operator->() const { return &m_value; } + operator const T*() const { return &m_value; } + T m_value; + }; + + template + struct SwigPySequence_InputIterator + { + typedef SwigPySequence_InputIterator self; + + typedef std::random_access_iterator_tag iterator_category; + typedef Reference reference; + typedef T value_type; + typedef T* pointer; + typedef Py_ssize_t difference_type; + + SwigPySequence_InputIterator() + { + } + + SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index) + : _seq(seq), _index(index) + { + } + + reference operator*() const + { + return reference(_seq, _index); + } + + SwigPySequence_ArrowProxy + operator->() const { + return SwigPySequence_ArrowProxy(operator*()); + } + + bool operator==(const self& ri) const + { + return (_index == ri._index) && (_seq == ri._seq); + } + + bool operator!=(const self& ri) const + { + return !(operator==(ri)); + } + + self& operator ++ () + { + ++_index; + return *this; + } + + self& operator -- () + { + --_index; + return *this; + } + + self& operator += (difference_type n) + { + _index += n; + return *this; + } + + self operator +(difference_type n) const + { + return self(_seq, _index + n); + } + + self& operator -= (difference_type n) + { + _index -= n; + return *this; + } + + self operator -(difference_type n) const + { + return self(_seq, _index - n); + } + + difference_type operator - (const self& ri) const + { + return _index - ri._index; + } + + bool operator < (const self& ri) const + { + return _index < ri._index; + } + + reference + operator[](difference_type n) const + { + return reference(_seq, _index + n); + } + + private: + PyObject* _seq; + difference_type _index; + }; + + // STL container wrapper around a Python sequence + template + struct SwigPySequence_Cont + { + typedef SwigPySequence_Ref reference; + typedef const SwigPySequence_Ref const_reference; + typedef T value_type; + typedef T* pointer; + typedef Py_ssize_t difference_type; + typedef size_t size_type; + typedef const pointer const_pointer; + typedef SwigPySequence_InputIterator iterator; + typedef SwigPySequence_InputIterator const_iterator; + + SwigPySequence_Cont(PyObject* seq) : _seq(0) + { + if (!PySequence_Check(seq)) { + throw std::invalid_argument("a sequence is expected"); + } + _seq = seq; + Py_INCREF(_seq); + } + + ~SwigPySequence_Cont() + { + Py_XDECREF(_seq); + } + + size_type size() const + { + return static_cast(PySequence_Size(_seq)); + } + + bool empty() const + { + return size() == 0; + } + + iterator begin() + { + return iterator(_seq, 0); + } + + const_iterator begin() const + { + return const_iterator(_seq, 0); + } + + iterator end() + { + return iterator(_seq, size()); + } + + const_iterator end() const + { + return const_iterator(_seq, size()); + } + + reference operator[](difference_type n) + { + return reference(_seq, n); + } + + const_reference operator[](difference_type n) const + { + return const_reference(_seq, n); + } + + bool check(bool set_err = true) const + { + Py_ssize_t s = size(); + for (Py_ssize_t i = 0; i < s; ++i) { + swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i); + if (!swig::check(item)) { + if (set_err) { + char msg[1024]; + sprintf(msg, "in sequence element %d", (int)i); + SWIG_Error(SWIG_RuntimeError, msg); + } + return false; + } + } + return true; + } + + private: + PyObject* _seq; + }; + +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +namespace swig { + template <> struct traits< int > { + typedef value_category category; + static const char* type_name() { return"int"; } + }; + template <> struct traits_asval< int > { + typedef int value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_int (obj, val); + } + }; + template <> struct traits_from< int > { + typedef int value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_int (val); + } + }; +} + + +namespace swig { + template + inline void + assign(const SwigPySeq& swigpyseq, Seq* seq) { + // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented + typedef typename SwigPySeq::value_type value_type; + typename SwigPySeq::const_iterator it = swigpyseq.begin(); + for (;it != swigpyseq.end(); ++it) { + seq->insert(seq->end(),(value_type)(*it)); + } + } + + template + struct traits_asptr_stdseq { + typedef Seq sequence; + typedef T value_type; + + static int asptr(PyObject *obj, sequence **seq) { + if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) { + sequence *p; + if (::SWIG_ConvertPtr(obj,(void**)&p, + swig::type_info(),0) == SWIG_OK) { + if (seq) *seq = p; + return SWIG_OLDOBJ; + } + } else if (PySequence_Check(obj)) { + try { + SwigPySequence_Cont swigpyseq(obj); + if (seq) { + sequence *pseq = new sequence(); + assign(swigpyseq, pseq); + *seq = pseq; + return SWIG_NEWOBJ; + } else { + return swigpyseq.check() ? SWIG_OK : SWIG_ERROR; + } + } catch (std::exception& e) { + if (seq) { + if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, e.what()); + } + } + return SWIG_ERROR; + } + } + return SWIG_ERROR; + } + }; + + template + struct traits_from_stdseq { + typedef Seq sequence; + typedef T value_type; + typedef typename Seq::size_type size_type; + typedef typename sequence::const_iterator const_iterator; + + static PyObject *from(const sequence& seq) { +#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS + swig_type_info *desc = swig::type_info(); + if (desc && desc->clientdata) { + return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); + } +#endif + size_type size = seq.size(); + if (size <= (size_type)INT_MAX) { + PyObject *obj = PyTuple_New((Py_ssize_t)size); + Py_ssize_t i = 0; + for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) { + PyTuple_SetItem(obj,i,swig::from(*it)); + } + return obj; + } else { + PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python"); + return NULL; + } + } + }; +} + + + namespace swig { + template + struct traits_asptr > { + static int asptr(PyObject *obj, std::vector **vec) { + return traits_asptr_stdseq >::asptr(obj, vec); + } + }; + + template + struct traits_from > { + static PyObject *from(const std::vector& vec) { + return traits_from_stdseq >::from(vec); + } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "int" "," "std::allocator< int >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){ + return self->size(); + } + +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long (unsigned long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLong(value) : PyLong_FromLong(static_cast< long >(value)); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_size_t (size_t value) +{ + return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); +} + +SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >()); + } +SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< int,std::allocator< int > >::difference_type id = i; + std::vector< int,std::allocator< int > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< int,std::allocator< int > >::difference_type id = i; + std::vector< int,std::allocator< int > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< int,std::allocator< int > >::difference_type id = i; + std::vector< int,std::allocator< int > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< int,std::allocator< int > >::difference_type id = i; + std::vector< int,std::allocator< int > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< int,std::allocator< int > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); } + +#define SWIG_FILE_WITH_INIT + +#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ + (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ + (PY_MAJOR_VERSION > 3)) +#define CAPSULES_SUPPORTED +#endif + +#ifndef NPY_ARRAY_C_CONTIGUOUS + #define NPY_ARRAY_C_CONTIGUOUS NPY_C_CONTIGUOUS + #define PyArray_SetBaseObject(arr, x) (PyArray_BASE(arr) = (x)) +#endif + + +#ifndef SWIG_FILE_WITH_INIT +# define NO_IMPORT_ARRAY +#endif +#include "stdio.h" +#include + + + #define SWIG_FILE_WITH_INIT + #include + #include + #include + #include + #include + #include + #include + //#include + #include + #include + #include + #include + #include + #include + #include + #include + + using namespace aruco; + + +/* Support older NumPy data type names +*/ +#if NDARRAY_VERSION < 0x01000000 +#define NPY_BOOL PyArray_BOOL +#define NPY_BYTE PyArray_BYTE +#define NPY_UBYTE PyArray_UBYTE +#define NPY_SHORT PyArray_SHORT +#define NPY_USHORT PyArray_USHORT +#define NPY_INT PyArray_INT +#define NPY_UINT PyArray_UINT +#define NPY_LONG PyArray_LONG +#define NPY_ULONG PyArray_ULONG +#define NPY_LONGLONG PyArray_LONGLONG +#define NPY_ULONGLONG PyArray_ULONGLONG +#define NPY_FLOAT PyArray_FLOAT +#define NPY_DOUBLE PyArray_DOUBLE +#define NPY_LONGDOUBLE PyArray_LONGDOUBLE +#define NPY_CFLOAT PyArray_CFLOAT +#define NPY_CDOUBLE PyArray_CDOUBLE +#define NPY_CLONGDOUBLE PyArray_CLONGDOUBLE +#define NPY_OBJECT PyArray_OBJECT +#define NPY_STRING PyArray_STRING +#define NPY_UNICODE PyArray_UNICODE +#define NPY_VOID PyArray_VOID +#define NPY_NTYPES PyArray_NTYPES +#define NPY_NOTYPE PyArray_NOTYPE +#define NPY_CHAR PyArray_CHAR +#define NPY_USERDEF PyArray_USERDEF +#define npy_intp intp + +#define NPY_MAX_BYTE MAX_BYTE +#define NPY_MIN_BYTE MIN_BYTE +#define NPY_MAX_UBYTE MAX_UBYTE +#define NPY_MAX_SHORT MAX_SHORT +#define NPY_MIN_SHORT MIN_SHORT +#define NPY_MAX_USHORT MAX_USHORT +#define NPY_MAX_INT MAX_INT +#define NPY_MIN_INT MIN_INT +#define NPY_MAX_UINT MAX_UINT +#define NPY_MAX_LONG MAX_LONG +#define NPY_MIN_LONG MIN_LONG +#define NPY_MAX_ULONG MAX_ULONG +#define NPY_MAX_LONGLONG MAX_LONGLONG +#define NPY_MIN_LONGLONG MIN_LONGLONG +#define NPY_MAX_ULONGLONG MAX_ULONGLONG +#define NPY_MAX_INTP MAX_INTP +#define NPY_MIN_INTP MIN_INTP + +#define NPY_FARRAY FARRAY +#define NPY_F_CONTIGUOUS F_CONTIGUOUS +#endif + + +/* Macros to extract array attributes. + */ +#define is_array(a) ((a) && PyArray_Check((PyArrayObject *)a)) +#define array_type(a) (int)(PyArray_TYPE(a)) +#define array_numdims(a) (((PyArrayObject *)a)->nd) +#define array_dimensions(a) (((PyArrayObject *)a)->dimensions) +#define array_size(a,i) (((PyArrayObject *)a)->dimensions[i]) +#define array_data(a) (((PyArrayObject *)a)->data) +#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a)) +#define array_is_native(a) (PyArray_ISNOTSWAPPED(a)) +#define array_is_fortran(a) (PyArray_ISFORTRAN(a)) + + + /* Given a PyObject, return a string describing its type. + */ + const char* pytype_string(PyObject* py_obj) { + if (py_obj == NULL ) return "C NULL value"; + if (py_obj == Py_None ) return "Python None" ; + if (PyCallable_Check(py_obj)) return "callable" ; + if (PyString_Check( py_obj)) return "string" ; + if (PyInt_Check( py_obj)) return "int" ; + if (PyFloat_Check( py_obj)) return "float" ; + if (PyDict_Check( py_obj)) return "dict" ; + if (PyList_Check( py_obj)) return "list" ; + if (PyTuple_Check( py_obj)) return "tuple" ; + if (PyModule_Check( py_obj)) return "module" ; +#if PY_MAJOR_VERSION < 3 + if (PyFile_Check( py_obj)) return "file" ; + if (PyInstance_Check(py_obj)) return "instance" ; +#endif + + return "unkown type"; + } + + /* Given a NumPy typecode, return a string describing the type. + */ + const char* typecode_string(int typecode) { + static const char* type_names[25] = {"bool", "byte", "unsigned byte", + "short", "unsigned short", "int", + "unsigned int", "long", "unsigned long", + "long long", "unsigned long long", + "float", "double", "long double", + "complex float", "complex double", + "complex long double", "object", + "string", "unicode", "void", "ntypes", + "notype", "char", "unknown"}; + return typecode < 24 ? type_names[typecode] : type_names[24]; + } + + /* Make sure input has correct numpy type. Allow character and byte + * to match. Also allow int and long to match. This is deprecated. + * You should use PyArray_EquivTypenums() instead. + */ + int type_match(int actual_type, int desired_type) { + return PyArray_EquivTypenums(actual_type, desired_type); + } + + + /* Given a PyObject pointer, cast it to a PyArrayObject pointer if + * legal. If not, set the python error string appropriately and + * return NULL. + */ + PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode) + { + PyArrayObject* ary = NULL; + if (is_array(input) && (typecode == NPY_NOTYPE || + PyArray_EquivTypenums(array_type(input), typecode))) + { + ary = (PyArrayObject*) input; + } + else if is_array(input) + { + const char* desired_type = typecode_string(typecode); + const char* actual_type = typecode_string(array_type(input)); + PyErr_Format(PyExc_TypeError, + "Array of type '%s' required. Array of type '%s' given", + desired_type, actual_type); + ary = NULL; + } + else + { + const char * desired_type = typecode_string(typecode); + const char * actual_type = pytype_string(input); + PyErr_Format(PyExc_TypeError, + "Array of type '%s' required. A '%s' was given", + desired_type, actual_type); + ary = NULL; + } + return ary; + } + + /* Convert the given PyObject to a NumPy array with the given + * typecode. On success, return a valid PyArrayObject* with the + * correct type. On failure, the python error string will be set and + * the routine returns NULL. + */ + PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode, + int* is_new_object) + { + PyArrayObject* ary = NULL; + PyObject* py_obj; + if (is_array(input) && (typecode == NPY_NOTYPE || + PyArray_EquivTypenums(array_type(input),typecode))) + { + ary = (PyArrayObject*) input; + *is_new_object = 0; + } + else + { + py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_DEFAULT); + /* If NULL, PyArray_FromObject will have set python error value.*/ + ary = (PyArrayObject*) py_obj; + *is_new_object = 1; + } + return ary; + } + + /* Given a PyArrayObject, check to see if it is contiguous. If so, + * return the input pointer and flag it as not a new object. If it is + * not contiguous, create a new PyArrayObject using the original data, + * flag it as a new object and return the pointer. + */ + PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object, + int min_dims, int max_dims) + { + PyArrayObject* result; + if (array_is_contiguous(ary)) + { + result = ary; + *is_new_object = 0; + } + else + { + result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary, + array_type(ary), + min_dims, + max_dims); + *is_new_object = 1; + } + return result; + } + + /* Given a PyArrayObject, check to see if it is Fortran-contiguous. + * If so, return the input pointer, but do not flag it as not a new + * object. If it is not Fortran-contiguous, create a new + * PyArrayObject using the original data, flag it as a new object + * and return the pointer. + */ + PyArrayObject* make_fortran(PyArrayObject* ary, int* is_new_object, + int min_dims, int max_dims) + { + PyArrayObject* result; + if (array_is_fortran(ary)) + { + result = ary; + *is_new_object = 0; + } + else + { + Py_INCREF(ary->descr); + result = (PyArrayObject*) PyArray_FromArray(ary, ary->descr, NPY_FORTRAN); + *is_new_object = 1; + } + return result; + } + + /* Convert a given PyObject to a contiguous PyArrayObject of the + * specified type. If the input object is not a contiguous + * PyArrayObject, a new one will be created and the new object flag + * will be set. + */ + PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input, + int typecode, + int* is_new_object) + { + int is_new1 = 0; + int is_new2 = 0; + PyArrayObject* ary2; + PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, + &is_new1); + if (ary1) + { + ary2 = make_contiguous(ary1, &is_new2, 0, 0); + if ( is_new1 && is_new2) + { + Py_DECREF(ary1); + } + ary1 = ary2; + } + *is_new_object = is_new1 || is_new2; + return ary1; + } + + /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the + * specified type. If the input object is not a Fortran-ordered + * PyArrayObject, a new one will be created and the new object flag + * will be set. + */ + PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input, + int typecode, + int* is_new_object) + { + int is_new1 = 0; + int is_new2 = 0; + PyArrayObject* ary2; + PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, + &is_new1); + if (ary1) + { + ary2 = make_fortran(ary1, &is_new2, 0, 0); + if (is_new1 && is_new2) + { + Py_DECREF(ary1); + } + ary1 = ary2; + } + *is_new_object = is_new1 || is_new2; + return ary1; + } + + + + /* Test whether a python object is contiguous. If array is + * contiguous, return 1. Otherwise, set the python error string and + * return 0. + */ + int require_contiguous(PyArrayObject* ary) + { + int contiguous = 1; + if (!array_is_contiguous(ary)) + { + PyErr_SetString(PyExc_TypeError, + "Array must be contiguous. A non-contiguous array was given"); + contiguous = 0; + } + return contiguous; + } + + /* Require that a numpy array is not byte-swapped. If the array is + * not byte-swapped, return 1. Otherwise, set the python error string + * and return 0. + */ + int require_native(PyArrayObject* ary) + { + int native = 1; + if (!array_is_native(ary)) + { + PyErr_SetString(PyExc_TypeError, + "Array must have native byteorder. " + "A byte-swapped array was given"); + native = 0; + } + return native; + } + + /* Require the given PyArrayObject to have a specified number of + * dimensions. If the array has the specified number of dimensions, + * return 1. Otherwise, set the python error string and return 0. + */ + int require_dimensions(PyArrayObject* ary, int exact_dimensions) + { + int success = 1; + if (array_numdims(ary) != exact_dimensions) + { + PyErr_Format(PyExc_TypeError, + "Array must have %d dimensions. Given array has %d dimensions", + exact_dimensions, array_numdims(ary)); + success = 0; + } + return success; + } + + /* Require the given PyArrayObject to have one of a list of specified + * number of dimensions. If the array has one of the specified number + * of dimensions, return 1. Otherwise, set the python error string + * and return 0. + */ + int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n) + { + int success = 0; + int i; + char dims_str[255] = ""; + char s[255]; + for (i = 0; i < n && !success; i++) + { + if (array_numdims(ary) == exact_dimensions[i]) + { + success = 1; + } + } + if (!success) + { + for (i = 0; i < n-1; i++) + { + sprintf(s, "%d, ", exact_dimensions[i]); + strcat(dims_str,s); + } + sprintf(s, " or %d", exact_dimensions[n-1]); + strcat(dims_str,s); + PyErr_Format(PyExc_TypeError, + "Array must have %s dimensions. Given array has %d dimensions", + dims_str, array_numdims(ary)); + } + return success; + } + + /* Require the given PyArrayObject to have a specified shape. If the + * array has the specified shape, return 1. Otherwise, set the python + * error string and return 0. + */ + int require_size(PyArrayObject* ary, npy_intp* size, int n) + { + int i; + int success = 1; + int len; + char desired_dims[255] = "["; + char s[255]; + char actual_dims[255] = "["; + for(i=0; i < n;i++) + { + if (size[i] != -1 && size[i] != array_size(ary,i)) + { + success = 0; + } + } + if (!success) + { + for (i = 0; i < n; i++) + { + if (size[i] == -1) + { + sprintf(s, "*,"); + } + else + { + sprintf(s, "%ld,", (long int)size[i]); + } + strcat(desired_dims,s); + } + len = strlen(desired_dims); + desired_dims[len-1] = ']'; + for (i = 0; i < n; i++) + { + sprintf(s, "%ld,", (long int)array_size(ary,i)); + strcat(actual_dims,s); + } + len = strlen(actual_dims); + actual_dims[len-1] = ']'; + PyErr_Format(PyExc_TypeError, + "Array must have shape of %s. Given array has shape of %s", + desired_dims, actual_dims); + } + return success; + } + + /* Require the given PyArrayObject to to be FORTRAN ordered. If the + * the PyArrayObject is already FORTRAN ordered, do nothing. Else, + * set the FORTRAN ordering flag and recompute the strides. + */ + int require_fortran(PyArrayObject* ary) + { + int success = 1; + int nd = array_numdims(ary); + int i; + if (array_is_fortran(ary)) return success; + /* Set the FORTRAN ordered flag */ + ary->flags = NPY_FARRAY; + /* Recompute the strides */ + ary->strides[0] = ary->strides[nd-1]; + for (i=1; i < nd; ++i) + ary->strides[i] = ary->strides[i-1] * array_size(ary,i-1); + return success; + } + + + + // convert NumPy type to OpenCV type + int numpy_type_to_mat_type(PyArrayObject *array, int channels) + { + switch (array_type(array)) { + case NPY_BYTE: return CV_MAKETYPE(CV_8S, channels); + case NPY_UBYTE: return CV_MAKETYPE(CV_8U, channels); + case NPY_SHORT: return CV_MAKETYPE(CV_16S, channels); + case NPY_USHORT: return CV_MAKETYPE(CV_16U, channels); + case NPY_INT: return CV_MAKETYPE(CV_32S, channels); + //case NPY_UINT: // does not exist + //case NPY_LONG: // does not exist + //case NPY_ULONG: // does not exist + case NPY_FLOAT: return CV_MAKETYPE(CV_32F, channels); + case NPY_DOUBLE: return CV_MAKETYPE(CV_64F, channels); + default: + PyErr_Format(PyExc_TypeError, + "Unsupported datatype: %s.", + typecode_string(array_type(array))); + } + return -1; + } + + // convert OpenCV type to NumPy type + int mat_type_to_numpy_type(int type) + { + // convert numpy type to CV type + switch (CV_MAT_DEPTH(type)) { + case CV_8S: return NPY_BYTE; + case CV_8U: return NPY_UBYTE; + case CV_16S: return NPY_SHORT; + case CV_16U: return NPY_USHORT; + case CV_32S: return NPY_INT; + //case NPY_UINT: // does not exist + //case NPY_LONG: // does not exist + //case NPY_ULONG: // does not exist + case CV_32F: return NPY_FLOAT; + case CV_64F: return NPY_DOUBLE; + default: + PyErr_Format(PyExc_TypeError, + "Unsupported OpenCV datatype: %d (depth: %d).", + type, CV_MAT_DEPTH(type)); + } + return -1; + } + + void delete_mat(void *ptr) + { + // printf("deleting underlying mat at %p\n", ptr); + cv::Mat *m = static_cast< cv::Mat* >(ptr); + assert (m != NULL); + delete m; + } + +#ifdef CAPSULES_SUPPORTED + void delete_mat_capsule(PyObject *obj) + { + // printf("deleting underlying mat at %p\n", ptr); + cv::Mat *m = static_cast< cv::Mat* >(PyCapsule_GetPointer(obj, NULL)); + assert (m != NULL); + delete m; + } +#endif + + + + cv::Scalar* array_to_scalar(PyObject* input) + { + PyArrayObject* array = obj_to_array_no_conversion(input, NPY_NOTYPE); + if (array == NULL) { + // error message is set by obj_to_array_no_conversion + return NULL; + } + + // creates 4-element integer array ToDo: diff. convert data types + size_t size = array_size(array, 0); + size_t step = array->strides[0]; + int data[4] = {0, 0, 0, 0}; + for(size_t i=0, j=0; istrides[0]; + int data[4] = {0, 0, 0, 0}; + for(size_t i=0, j=0; i 4) { + PyErr_Format(PyExc_TypeError, + "Array can have a maximum of 4 channels. Input as %d.", channels); + return NULL; + } + } + else { + PyErr_Format(PyExc_TypeError, + "Array must be 2- or 3-dimensional. Input is %d-dimensional.", ndims); + return NULL; + } + + // convert NumPy type to OpenCV type + if ((type = numpy_type_to_mat_type(array, channels)) == -1) + return NULL; + + // check that array is in C order + for (int i = 0; i < ndims-1; ++i) { + if (PyArray_STRIDE(array, i) < PyArray_STRIDE(array, i+1)) { + PyErr_Format(PyExc_TypeError, + "Array is not in C order: stride of dim %d: %ld < stride of dim %d: %ld", + i, PyArray_STRIDE(array, i), i+1, PyArray_STRIDE(array, i+1)); + return NULL; + } + } + + // use stride of first dimension as stepsize + // and check strides of other dimensions + int step = ((PyArrayObject *)array)->strides[0]; + if (PyArray_STRIDE(array, 1) != channels * PyArray_ITEMSIZE(array)) { + PyErr_Format(PyExc_TypeError, + "Array cannot have strides in other than 1st dimension (rows). Dim 2: %ld vs %d", + PyArray_STRIDE(array, 1), channels * PyArray_ITEMSIZE(array)); + return NULL; + } + + // create new view onto the data + return new cv::Mat(array_size(array, 0), array_size(array, 1), type, array_data(array), step); + } + + PyObject* mat_to_array(const cv::Mat& mat) + { + // handle empty mat + if (mat.empty()) { + npy_intp dims[1] = { 0 }; + int type = mat_type_to_numpy_type(mat.type()); + PyObject* array = PyArray_EMPTY(1, dims, type, 0); + return array; + } + + npy_intp dims[3] = { mat.rows, mat.cols, mat.channels() }; + npy_intp strides[3] = { (npy_intp)mat.step, (npy_intp)mat.elemSize(), (npy_intp)mat.elemSize1()}; + int ndims = (mat.channels() > 1) ? 3 : 2; + int type = mat_type_to_numpy_type(mat.type()); + int flags = NPY_WRITEABLE; + if (mat.isContinuous()) + flags |= NPY_C_CONTIGUOUS; + PyObject* array = PyArray_New(&PyArray_Type, ndims, dims, type, + strides, mat.data, 0, flags, NULL); + return array; + } + + PyObject* point2f_to_array(cv::Point2f* point) + { + npy_intp dims = 2; + npy_intp strides[1] = { 1 }; + int flags = NPY_WRITEABLE; + float *data = new float[2]; + data[0] = point->x; + data[1] = point->y; + PyObject* array = PyArray_SimpleNewFromData(1, &dims, NPY_FLOAT, data); + return array; + } + + + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor(void) +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +SWIGINTERN int +SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) +{ +#if PY_VERSION_HEX>=0x03000000 + if (PyUnicode_Check(obj)) +#else + if (PyString_Check(obj)) +#endif + { + char *cstr; Py_ssize_t len; +#if PY_VERSION_HEX>=0x03000000 + if (!alloc && cptr) { + /* We can't allow converting without allocation, since the internal + representation of string in Python 3 is UCS-2/UCS-4 but we require + a UTF-8 representation. + TODO(bhy) More detailed explanation */ + return SWIG_RuntimeError; + } + obj = PyUnicode_AsUTF8String(obj); + PyBytes_AsStringAndSize(obj, &cstr, &len); + if(alloc) *alloc = SWIG_NEWOBJ; +#else + PyString_AsStringAndSize(obj, &cstr, &len); +#endif + if (cptr) { + if (alloc) { + /* + In python the user should not be able to modify the inner + string representation. To warranty that, if you define + SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string + buffer is always returned. + + The default behavior is just to return the pointer value, + so, be careful. + */ +#if defined(SWIG_PYTHON_SAFE_CSTRINGS) + if (*alloc != SWIG_OLDOBJ) +#else + if (*alloc == SWIG_NEWOBJ) +#endif + { + *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1))); + *alloc = SWIG_NEWOBJ; + } else { + *cptr = cstr; + *alloc = SWIG_OLDOBJ; + } + } else { + #if PY_VERSION_HEX>=0x03000000 + assert(0); /* Should never reach here in Python 3 */ + #endif + *cptr = SWIG_Python_str_AsChar(obj); + } + } + if (psize) *psize = len + 1; +#if PY_VERSION_HEX>=0x03000000 + Py_XDECREF(obj); +#endif + return SWIG_OK; + } else { +#if defined(SWIG_PYTHON_2_UNICODE) +#if PY_VERSION_HEX<0x03000000 + if (PyUnicode_Check(obj)) { + char *cstr; Py_ssize_t len; + if (!alloc && cptr) { + return SWIG_RuntimeError; + } + obj = PyUnicode_AsUTF8String(obj); + if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) { + if (cptr) { + if (alloc) *alloc = SWIG_NEWOBJ; + *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1))); + } + if (psize) *psize = len + 1; + + Py_XDECREF(obj); + return SWIG_OK; + } else { + Py_XDECREF(obj); + } + } +#endif +#endif + + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + if (pchar_descriptor) { + void* vptr = 0; + if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { + if (cptr) *cptr = (char *) vptr; + if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; + if (alloc) *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + } + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsPtr_std_string (PyObject * obj, std::string **val) +{ + char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ; + if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) { + if (buf) { + if (val) *val = new std::string(buf, size - 1); + if (alloc == SWIG_NEWOBJ) delete[] buf; + return SWIG_NEWOBJ; + } else { + if (val) *val = 0; + return SWIG_OLDOBJ; + } + } else { + static int init = 0; + static swig_type_info* descriptor = 0; + if (!init) { + descriptor = SWIG_TypeQuery("std::string" " *"); + init = 1; + } + if (descriptor) { + std::string *vptr; + int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0); + if (SWIG_IsOK(res) && val) *val = vptr; + return res; + } + } + return SWIG_ERROR; +} + + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + +/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */ +#ifndef SWIG_isfinite +# if defined(isfinite) +# define SWIG_isfinite(X) (isfinite(X)) +# elif defined(_MSC_VER) +# define SWIG_isfinite(X) (_finite(X)) +# elif defined(__sun) && defined(__SVR4) +# include +# define SWIG_isfinite(X) (finite(X)) +# endif +#endif + + +/* Accept infinite as a valid float value unless we are unable to check if a value is finite */ +#ifdef SWIG_isfinite +# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X)) +#else +# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX)) +#endif + + +SWIGINTERN int +SWIG_AsVal_float (PyObject * obj, float *val) +{ + double v; + int res = SWIG_AsVal_double (obj, &v); + if (SWIG_IsOK(res)) { + if (SWIG_Float_Overflow_Check(v)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< float >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + if (carray) { + if (size > INT_MAX) { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + return pchar_descriptor ? + SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { +#if PY_VERSION_HEX >= 0x03000000 +#if PY_VERSION_HEX >= 0x03010000 + return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); +#else + return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#endif +#else + return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#endif + } + } else { + return SWIG_Py_Void(); + } +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_std_string (const std::string& s) +{ + return SWIG_FromCharPtrAndSize(s.data(), s.size()); +} + + + namespace swig { + template <> struct traits< cv::Point2f > { + typedef pointer_category category; + static const char* type_name() { return"cv::Point2f"; } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "cv::Point2f" "," "std::allocator< cv::Point2f >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_cv_Point2f_Sg__iterator(std::vector< cv::Point2f > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_cv_Point2f_Sg____nonzero__(std::vector< cv::Point2f > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_cv_Point2f_Sg____bool__(std::vector< cv::Point2f > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< cv::Point2f >::size_type std_vector_Sl_cv_Point2f_Sg____len__(std::vector< cv::Point2f > const *self){ + return self->size(); + } +SWIGINTERN std::vector< cv::Point2f,std::allocator< cv::Point2f > > *std_vector_Sl_cv_Point2f_Sg____getslice__(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< cv::Point2f,std::allocator< cv::Point2f > >()); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_1(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____delslice__(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< cv::Point2f,std::allocator< cv::Point2f > > *std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_0(std::vector< cv::Point2f > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_0(std::vector< cv::Point2f > *self,PySliceObject *slice,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_1(std::vector< cv::Point2f > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_1(std::vector< cv::Point2f > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< cv::Point2f >::value_type const &std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_1(std::vector< cv::Point2f > const *self,std::vector< cv::Point2f >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_2(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< cv::Point2f >::value_type std_vector_Sl_cv_Point2f_Sg__pop(std::vector< cv::Point2f > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< cv::Point2f,std::allocator< cv::Point2f > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg__append(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< cv::Point2f >::iterator std_vector_Sl_cv_Point2f_Sg__erase__SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< cv::Point2f >::iterator std_vector_Sl_cv_Point2f_Sg__erase__SWIG_1(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator first,std::vector< cv::Point2f >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< cv::Point2f >::iterator std_vector_Sl_cv_Point2f_Sg__insert__SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator pos,std::vector< cv::Point2f >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_cv_Point2f_Sg__insert__SWIG_1(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator pos,std::vector< cv::Point2f >::size_type n,std::vector< cv::Point2f >::value_type const &x){ self->insert(pos, n, x); } + + namespace swig { + template <> struct traits< aruco::Marker > { + typedef pointer_category category; + static const char* type_name() { return"aruco::Marker"; } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "aruco::Marker" "," "std::allocator< aruco::Marker >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__iterator(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____nonzero__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____bool__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____len__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self){ + return self->size(); + } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > > *std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< aruco::Marker,std::allocator< aruco::Marker > >()); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > > *std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_2(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__pop(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__append(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator first,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator pos,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator pos,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type n,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ self->insert(pos, n, x); } + + namespace swig { + template <> struct traits< aruco::Marker3DInfo > { + typedef pointer_category category; + static const char* type_name() { return"aruco::Marker3DInfo"; } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "aruco::Marker3DInfo" "," "std::allocator< aruco::Marker3DInfo >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_aruco_Marker3DInfo_Sg__iterator(std::vector< aruco::Marker3DInfo > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_aruco_Marker3DInfo_Sg____nonzero__(std::vector< aruco::Marker3DInfo > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_aruco_Marker3DInfo_Sg____bool__(std::vector< aruco::Marker3DInfo > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< aruco::Marker3DInfo >::size_type std_vector_Sl_aruco_Marker3DInfo_Sg____len__(std::vector< aruco::Marker3DInfo > const *self){ + return self->size(); + } +SWIGINTERN std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *std_vector_Sl_aruco_Marker3DInfo_Sg____getslice__(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >()); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_1(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____delslice__(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_0(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_0(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_1(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_1(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< aruco::Marker3DInfo >::value_type const &std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_1(std::vector< aruco::Marker3DInfo > const *self,std::vector< aruco::Marker3DInfo >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_2(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< aruco::Marker3DInfo >::value_type std_vector_Sl_aruco_Marker3DInfo_Sg__pop(std::vector< aruco::Marker3DInfo > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg__append(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< aruco::Marker3DInfo >::iterator std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< aruco::Marker3DInfo >::iterator std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_1(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator first,std::vector< aruco::Marker3DInfo >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< aruco::Marker3DInfo >::iterator std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator pos,std::vector< aruco::Marker3DInfo >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_1(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator pos,std::vector< aruco::Marker3DInfo >::size_type n,std::vector< aruco::Marker3DInfo >::value_type const &x){ self->insert(pos, n, x); } + + #define SWIG_From_double PyFloat_FromDouble + + +SWIGINTERNINLINE PyObject * +SWIG_From_float (float value) +{ + return SWIG_From_double (value); +} + +SWIGINTERN cv::Point2f aruco_Marker___getitem__(aruco::Marker *self,int i){ + return self->at(i); + } + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "aruco_wrap.h" + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n" + " Possible C/C++ prototypes are:\n" + " swig::SwigPyIterator::incr(size_t)\n" + " swig::SwigPyIterator::incr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n" + " Possible C/C++ prototypes are:\n" + " swig::SwigPyIterator::decr(size_t)\n" + " swig::SwigPyIterator::decr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + ptrdiff_t result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2); + } + catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2); + } + catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->next(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->__next__(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->previous(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->advance(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + ptrdiff_t result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_0(self, args); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< int,std::allocator< int > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); + } + arg3 = static_cast< std::vector< int >::difference_type >(val3); + try { + result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); + } + arg3 = static_cast< std::vector< int >::difference_type >(val3); + try { + std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::difference_type arg3 ; + std::vector< int,std::allocator< int > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); + } + arg3 = static_cast< std::vector< int >::difference_type >(val3); + { + std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt___setslice____SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorInt___setslice____SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n" + " std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); + } + arg3 = static_cast< std::vector< int >::difference_type >(val3); + try { + std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + try { + std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int,std::allocator< int > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< int,std::allocator< int > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + { + std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___setitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_VectorInt___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::__delitem__(std::vector< int >::difference_type)\n" + " std::vector< int >::__delitem__(PySliceObject *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + try { + result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_int(static_cast< int >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_VectorInt___getitem____SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::__getitem__(PySliceObject *)\n" + " std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,arg2,(int const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_VectorInt___setitem____SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorInt___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt___setitem____SWIG_2(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n" + " std::vector< int >::__setitem__(PySliceObject *)\n" + " std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + try { + result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< int >::value_type temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); + } + temp2 = static_cast< std::vector< int >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail; + result = (std::vector< int > *)new std::vector< int >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail; + { + std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (bool)((std::vector< int > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); + } + arg2 = reinterpret_cast< std::vector< int > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::allocator< int > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'"); + } + arg1 = static_cast< std::vector< int >::size_type >(val1); + result = (std::vector< int > *)new std::vector< int >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + std::vector< int >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'"); + } + } + result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_VectorInt_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_VectorInt_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::erase(std::vector< int >::iterator)\n" + " std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int >::size_type arg1 ; + std::vector< int >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< int >::value_type temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'"); + } + arg1 = static_cast< std::vector< int >::size_type >(val1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); + } + temp2 = static_cast< std::vector< int >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_VectorInt__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_VectorInt__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorInt__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_VectorInt__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorInt'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::vector()\n" + " std::vector< int >::vector(std::vector< int > const &)\n" + " std::vector< int >::vector(std::vector< int >::size_type)\n" + " std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< int >::value_type temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); + } + temp2 = static_cast< std::vector< int >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< int >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front(); + resultobj = SWIG_From_int(static_cast< int >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back(); + resultobj = SWIG_From_int(static_cast< int >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt_resize__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::resize(std::vector< int >::size_type)\n" + " std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + std::vector< int >::size_type arg3 ; + std::vector< int >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< int >::value_type temp4 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'"); + } + arg3 = static_cast< std::vector< int >::size_type >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'"); + } + temp4 = static_cast< std::vector< int >::value_type >(val4); + arg4 = &temp4; + std_vector_Sl_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(int const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorInt_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n" + " std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ARUCO_VERSION_MAJOR_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *module; + PyObject *d; + if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; + d = PyModule_GetDict(module); + if (!d) return NULL; + SWIG_Python_SetConstant(d, "ARUCO_VERSION_MAJOR",SWIG_From_int(static_cast< int >(3))); + return SWIG_Py_Void(); +} + + +SWIGINTERN PyObject *ARUCO_VERSION_MINOR_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *module; + PyObject *d; + if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; + d = PyModule_GetDict(module); + if (!d) return NULL; + SWIG_Python_SetConstant(d, "ARUCO_VERSION_MINOR",SWIG_From_int(static_cast< int >(0))); + return SWIG_Py_Void(); +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_CameraMatrix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Mat arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + cv::Mat *mat2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_CameraMatrix_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CameraMatrix_set" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + if (arg1) (arg1)->CameraMatrix = arg2; + resultobj = SWIG_Py_Void(); + { + + } + { + if (mat2 != NULL) + delete mat2; + } + return resultobj; +fail: + { + if (mat2 != NULL) + delete mat2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_CameraMatrix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_CameraMatrix_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CameraMatrix_get" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + result = ((arg1)->CameraMatrix); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_Distorsion_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Mat arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + cv::Mat *mat2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_Distorsion_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_Distorsion_set" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + if (arg1) (arg1)->Distorsion = arg2; + resultobj = SWIG_Py_Void(); + { + + } + { + if (mat2 != NULL) + delete mat2; + } + return resultobj; +fail: + { + if (mat2 != NULL) + delete mat2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_Distorsion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_Distorsion_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_Distorsion_get" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + result = ((arg1)->Distorsion); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_CamSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Size arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_CamSize_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CamSize_set" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + if (arg1) (arg1)->CamSize = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_CamSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Size result; + + if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_CamSize_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CamSize_get" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + result = ((arg1)->CamSize); + resultobj = SWIG_NewPointerObj((new cv::Size(static_cast< const cv::Size& >(result))), SWIGTYPE_p_cv__Size, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CameraParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_CameraParameters")) SWIG_fail; + result = (aruco::CameraParameters *)new aruco::CameraParameters(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CameraParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat arg1 ; + cv::Mat arg2 ; + cv::Size arg3 ; + cv::Mat *mat1 ; + cv::Mat *mat2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + aruco::CameraParameters *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:new_CameraParameters",&obj0,&obj1,&obj2)) SWIG_fail; + { + mat1 = array_to_mat(obj0); + if (mat1 == NULL) + SWIG_fail; + arg1 = *mat1; + } + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + { + arg3 = *array_to_size(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + result = (aruco::CameraParameters *)new aruco::CameraParameters(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_NEW | 0 ); + { + + } + { + + } + { + if (mat1 != NULL) + delete mat1; + } + { + if (mat2 != NULL) + delete mat2; + } + return resultobj; +fail: + { + if (mat1 != NULL) + delete mat1; + } + { + if (mat2 != NULL) + delete mat2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Mat arg2 ; + cv::Mat arg3 ; + cv::Size arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + cv::Mat *mat2 ; + cv::Mat *mat3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:CameraParameters_setParams",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_setParams" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + { + mat3 = array_to_mat(obj2); + if (mat3 == NULL) + SWIG_fail; + arg3 = *mat3; + } + { + arg4 = *array_to_size(obj3); + if (&arg4 == NULL) + SWIG_fail; + } + (arg1)->setParams(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + { + + } + { + + } + { + if (mat2 != NULL) + delete mat2; + } + { + if (mat3 != NULL) + delete mat3; + } + return resultobj; +fail: + { + if (mat2 != NULL) + delete mat2; + } + { + if (mat3 != NULL) + delete mat3; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CameraParameters__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::CameraParameters *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_CameraParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraParameters" "', argument " "1"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraParameters" "', argument " "1"" of type '" "aruco::CameraParameters const &""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + result = (aruco::CameraParameters *)new aruco::CameraParameters((aruco::CameraParameters const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CameraParameters(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_CameraParameters__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CameraParameters__SWIG_2(self, args); + } + } + if (argc == 3) { + int _v; + { + _v = is_array(argv[0]) || PySequence_Check(argv[0]); + } + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + return _wrap_new_CameraParameters__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CameraParameters'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::CameraParameters::CameraParameters()\n" + " aruco::CameraParameters::CameraParameters(cv::Mat,cv::Mat,cv::Size)\n" + " aruco::CameraParameters::CameraParameters(aruco::CameraParameters const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_isValid",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_isValid" "', argument " "1"" of type '" "aruco::CameraParameters const *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + result = (bool)((aruco::CameraParameters const *)arg1)->isValid(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_saveToFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + std::string arg2 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CameraParameters_saveToFile",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_saveToFile" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CameraParameters_saveToFile" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CameraParameters_saveToFile" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + (arg1)->saveToFile(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_saveToFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_saveToFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_saveToFile" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CameraParameters_saveToFile" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->saveToFile(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_saveToFile(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CameraParameters_saveToFile__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CameraParameters_saveToFile__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CameraParameters_saveToFile'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::CameraParameters::saveToFile(std::string,bool)\n" + " aruco::CameraParameters::saveToFile(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_readFromXMLFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_readFromXMLFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_readFromXMLFile" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CameraParameters_readFromXMLFile" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->readFromXMLFile(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Size arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_resize" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_getCameraLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat arg1 ; + cv::Mat arg2 ; + cv::Mat *mat1 ; + cv::Mat *mat2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Point3f result; + + if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_getCameraLocation",&obj0,&obj1)) SWIG_fail; + { + mat1 = array_to_mat(obj0); + if (mat1 == NULL) + SWIG_fail; + arg1 = *mat1; + } + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + result = aruco::CameraParameters::getCameraLocation(arg1,arg2); + resultobj = SWIG_NewPointerObj((new cv::Point3f(static_cast< const cv::Point3f& >(result))), SWIGTYPE_p_cv__Point3f, SWIG_POINTER_OWN | 0 ); + { + + } + { + + } + { + if (mat1 != NULL) + delete mat1; + } + { + if (mat2 != NULL) + delete mat2; + } + return resultobj; +fail: + { + if (mat1 != NULL) + delete mat1; + } + { + if (mat2 != NULL) + delete mat2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_glGetProjectionMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Size arg2 ; + cv::Size arg3 ; + double *arg4 ; + double arg5 ; + double arg6 ; + bool arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CameraParameters_glGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + { + arg3 = *array_to_size(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + ecode6 = SWIG_AsVal_double(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + (arg1)->glGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_glGetProjectionMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Size arg2 ; + cv::Size arg3 ; + double *arg4 ; + double arg5 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CameraParameters_glGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + { + arg3 = *array_to_size(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + ecode6 = SWIG_AsVal_double(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + (arg1)->glGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_glGetProjectionMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 7) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CameraParameters_glGetProjectionMatrix__SWIG_1(self, args); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CameraParameters_glGetProjectionMatrix__SWIG_0(self, args); + } + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CameraParameters_glGetProjectionMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::CameraParameters::glGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double,bool)\n" + " aruco::CameraParameters::glGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Size arg2 ; + cv::Size arg3 ; + double *arg4 ; + double arg5 ; + double arg6 ; + bool arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CameraParameters_OgreGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + { + arg3 = *array_to_size(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + ecode6 = SWIG_AsVal_double(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + (arg1)->OgreGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + cv::Size arg2 ; + cv::Size arg3 ; + double *arg4 ; + double arg5 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CameraParameters_OgreGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + { + arg3 = *array_to_size(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + ecode6 = SWIG_AsVal_double(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + (arg1)->OgreGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_OgreGetProjectionMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 7) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_1(self, args); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_0(self, args); + } + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CameraParameters_OgreGetProjectionMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::CameraParameters::OgreGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double,bool)\n" + " aruco::CameraParameters::OgreGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CameraParameters_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat *arg1 = 0 ; + cv::Mat *arg2 = 0 ; + int arg3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CameraParameters_getRTMatrix",&obj0,&obj1,&obj2)) SWIG_fail; + { + arg1 = array_to_mat(obj0); + if (arg1 == NULL) + SWIG_fail; + } + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CameraParameters_getRTMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = aruco::CameraParameters::getRTMatrix((cv::Mat const &)*arg1,(cv::Mat const &)*arg2,arg3); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + { + + } + { + + } + { + if (arg1 != NULL) + delete arg1; + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg1 != NULL) + delete arg1; + } + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CameraParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_CameraParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraParameters" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CameraParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__CameraParameters, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat *arg1 = 0 ; + aruco::CameraParameters *arg2 = 0 ; + cv::Mat *arg3 = 0 ; + cv::Mat *arg4 = 0 ; + float arg5 ; + uchar *data_ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + float val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + { + arg1 = array_to_mat(obj0); + if (arg1 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr1 = arg1->data; + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); + { + arg3 = array_to_mat(obj2); + if (arg3 == NULL) + SWIG_fail; + } + { + arg4 = array_to_mat(obj3); + if (arg4 == NULL) + SWIG_fail; + } + ecode5 = SWIG_AsVal_float(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "5"" of type '" "float""'"); + } + arg5 = static_cast< float >(val5); + aruco::CvDrawingUtils::draw3dAxis(*arg1,(aruco::CameraParameters const &)*arg2,(cv::Mat const &)*arg3,(cv::Mat const &)*arg4,arg5); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr1 != arg1->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg1->rows, arg1->cols, arg1->type()); + SWIG_fail; + } + } + { + + } + { + + } + { + if (arg1 != NULL) + delete arg1; + } + { + if (arg3 != NULL) + delete arg3; + } + { + if (arg4 != NULL) + delete arg4; + } + return resultobj; +fail: + { + if (arg1 != NULL) + delete arg1; + } + { + if (arg3 != NULL) + delete arg3; + } + { + if (arg4 != NULL) + delete arg4; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat *arg1 = 0 ; + Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + uchar *data_ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2)) SWIG_fail; + { + arg1 = array_to_mat(obj0); + if (arg1 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr1 = arg1->data; + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); + } + arg2 = reinterpret_cast< Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + aruco::CvDrawingUtils::draw3dAxis(*arg1,*arg2,(aruco::CameraParameters const &)*arg3); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr1 != arg1->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg1->rows, arg1->cols, arg1->type()); + SWIG_fail; + } + } + { + if (arg1 != NULL) + delete arg1; + } + return resultobj; +fail: + { + if (arg1 != NULL) + delete arg1; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + { + _v = is_array(argv[0]) || PySequence_Check(argv[0]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvDrawingUtils_draw3dAxis__SWIG_1(self, args); + } + } + } + } + if (argc == 5) { + int _v; + { + _v = is_array(argv[0]) || PySequence_Check(argv[0]); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + { + _v = true;//is_array(argv[3]) || PySequence_Check(argv[3]); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvDrawingUtils_draw3dAxis__SWIG_0(self, args); + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CvDrawingUtils_draw3dAxis'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,aruco::CameraParameters const &,cv::Mat const &,cv::Mat const &,float)\n" + " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,Marker &,aruco::CameraParameters const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat *arg1 = 0 ; + Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + bool arg4 ; + uchar *data_ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:CvDrawingUtils_draw3dCube",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + { + arg1 = array_to_mat(obj0); + if (arg1 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr1 = arg1->data; + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); + } + arg2 = reinterpret_cast< Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + aruco::CvDrawingUtils::draw3dCube(*arg1,*arg2,(aruco::CameraParameters const &)*arg3,arg4); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr1 != arg1->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg1->rows, arg1->cols, arg1->type()); + SWIG_fail; + } + } + { + if (arg1 != NULL) + delete arg1; + } + return resultobj; +fail: + { + if (arg1 != NULL) + delete arg1; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat *arg1 = 0 ; + Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + uchar *data_ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CvDrawingUtils_draw3dCube",&obj0,&obj1,&obj2)) SWIG_fail; + { + arg1 = array_to_mat(obj0); + if (arg1 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr1 = arg1->data; + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); + } + arg2 = reinterpret_cast< Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + aruco::CvDrawingUtils::draw3dCube(*arg1,*arg2,(aruco::CameraParameters const &)*arg3); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr1 != arg1->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg1->rows, arg1->cols, arg1->type()); + SWIG_fail; + } + } + { + if (arg1 != NULL) + delete arg1; + } + return resultobj; +fail: + { + if (arg1 != NULL) + delete arg1; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + { + _v = is_array(argv[0]) || PySequence_Check(argv[0]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvDrawingUtils_draw3dCube__SWIG_1(self, args); + } + } + } + } + if (argc == 4) { + int _v; + { + _v = is_array(argv[0]) || PySequence_Check(argv[0]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvDrawingUtils_draw3dCube__SWIG_0(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CvDrawingUtils_draw3dCube'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &,bool)\n" + " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_CvDrawingUtils(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CvDrawingUtils *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_CvDrawingUtils")) SWIG_fail; + result = (aruco::CvDrawingUtils *)new aruco::CvDrawingUtils(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CvDrawingUtils, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CvDrawingUtils(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CvDrawingUtils *arg1 = (aruco::CvDrawingUtils *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_CvDrawingUtils",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CvDrawingUtils, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvDrawingUtils" "', argument " "1"" of type '" "aruco::CvDrawingUtils *""'"); + } + arg1 = reinterpret_cast< aruco::CvDrawingUtils * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CvDrawingUtils_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__CvDrawingUtils, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Debug_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + + if (!PyArg_ParseTuple(args,(char *)":Debug_init")) SWIG_fail; + aruco::Debug::init(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Debug_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Debug_setLevel",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Debug_setLevel" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + aruco::Debug::setLevel(arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Debug_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int result; + + if (!PyArg_ParseTuple(args,(char *)":Debug_getLevel")) SWIG_fail; + result = (int)aruco::Debug::getLevel(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Debug_addString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Debug_addString",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Debug_addString" "', argument " "1"" of type '" "std::string &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Debug_addString" "', argument " "1"" of type '" "std::string &""'"); + } + arg1 = reinterpret_cast< std::string * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Debug_addString" "', argument " "2"" of type '" "std::string &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Debug_addString" "', argument " "2"" of type '" "std::string &""'"); + } + arg2 = reinterpret_cast< std::string * >(argp2); + aruco::Debug::addString(*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Debug_getString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:Debug_getString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Debug_getString" "', argument " "1"" of type '" "std::string &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Debug_getString" "', argument " "1"" of type '" "std::string &""'"); + } + arg1 = reinterpret_cast< std::string * >(argp1); + result = aruco::Debug::getString(*arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Debug_getFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:Debug_getFileName",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Debug_getFileName" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::Debug::getFileName(arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Debug *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Debug")) SWIG_fail; + result = (aruco::Debug *)new aruco::Debug(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Debug, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Debug *arg1 = (aruco::Debug *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Debug",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Debug, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Debug" "', argument " "1"" of type '" "aruco::Debug *""'"); + } + arg1 = reinterpret_cast< aruco::Debug * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Debug_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Debug, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Dictionary__is(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + uint64_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Dictionary__is",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary__is" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint64_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dictionary__is" "', argument " "2"" of type '" "uint64_t""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary__is" "', argument " "2"" of type '" "uint64_t""'"); + } else { + uint64_t * temp = reinterpret_cast< uint64_t * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (bool)((aruco::Dictionary const *)arg1)->is(arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Dictionary::DICT_TYPES result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getType" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + result = (aruco::Dictionary::DICT_TYPES)((aruco::Dictionary const *)arg1)->getType(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + uint64_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_size" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + result = ((aruco::Dictionary const *)arg1)->size(); + resultobj = SWIG_NewPointerObj((new uint64_t(static_cast< const uint64_t& >(result))), SWIGTYPE_p_uint64_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_nbits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + uint32_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_nbits",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_nbits" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + result = ((aruco::Dictionary const *)arg1)->nbits(); + resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_tau(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + uint32_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_tau",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_tau" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + result = ((aruco::Dictionary const *)arg1)->tau(); + resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getName" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + result = ((aruco::Dictionary const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getMapCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::map< uint64_t,uint16_t > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getMapCode",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMapCode" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + result = (std::map< uint64_t,uint16_t > *) &((aruco::Dictionary const *)arg1)->getMapCode(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + uint64_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Dictionary_at",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_at" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint64_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dictionary_at" "', argument " "2"" of type '" "uint64_t""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_at" "', argument " "2"" of type '" "uint64_t""'"); + } else { + uint64_t * temp = reinterpret_cast< uint64_t * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (int)(arg1)->at(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + int arg2 ; + int arg3 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + bool val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dictionary_getMarkerImage_id" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + ecode6 = SWIG_AsVal_bool(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dictionary_getMarkerImage_id" "', argument " "6"" of type '" "bool""'"); + } + arg6 = static_cast< bool >(val6); + result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5,arg6); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + int arg2 ; + int arg3 ; + bool arg4 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dictionary_getMarkerImage_id" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + int arg2 ; + int arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + result = (arg1)->getMarkerImage_id(arg2,arg3,arg4); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (arg1)->getMarkerImage_id(arg2,arg3); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 6) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Dictionary_getMarkerImage_id__SWIG_3(self, args); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Dictionary_getMarkerImage_id__SWIG_2(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Dictionary_getMarkerImage_id__SWIG_1(self, args); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Dictionary_getMarkerImage_id__SWIG_0(self, args); + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_getMarkerImage_id'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool,bool)\n" + " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool)\n" + " aruco::Dictionary::getMarkerImage_id(int,int,bool)\n" + " aruco::Dictionary::getMarkerImage_id(int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_createMarkerMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + cv::Size arg2 ; + int arg3 ; + int arg4 ; + std::vector< int,std::allocator< int > > *arg5 = 0 ; + bool arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 = SWIG_OLDOBJ ; + bool val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + aruco::MarkerMap result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Dictionary_createMarkerMap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_createMarkerMap" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_createMarkerMap" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_createMarkerMap" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + { + std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; + res5 = swig::asptr(obj4, &ptr); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + arg5 = ptr; + } + ecode6 = SWIG_AsVal_bool(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dictionary_createMarkerMap" "', argument " "6"" of type '" "bool""'"); + } + arg6 = static_cast< bool >(val6); + result = (arg1)->createMarkerMap(arg2,arg3,arg4,(std::vector< int,std::allocator< int > > const &)*arg5,arg6); + resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); + if (SWIG_IsNewObj(res5)) delete arg5; + return resultobj; +fail: + if (SWIG_IsNewObj(res5)) delete arg5; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_createMarkerMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + cv::Size arg2 ; + int arg3 ; + int arg4 ; + std::vector< int,std::allocator< int > > *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + aruco::MarkerMap result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:Dictionary_createMarkerMap",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_createMarkerMap" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + { + arg2 = *array_to_size(obj1); + if (&arg2 == NULL) + SWIG_fail; + } + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_createMarkerMap" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_createMarkerMap" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + { + std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; + res5 = swig::asptr(obj4, &ptr); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + arg5 = ptr; + } + result = (arg1)->createMarkerMap(arg2,arg3,arg4,(std::vector< int,std::allocator< int > > const &)*arg5); + resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); + if (SWIG_IsNewObj(res5)) delete arg5; + return resultobj; +fail: + if (SWIG_IsNewObj(res5)) delete arg5; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_createMarkerMap(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 6) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[4], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Dictionary_createMarkerMap__SWIG_1(self, args); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[4], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Dictionary_createMarkerMap__SWIG_0(self, args); + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_createMarkerMap'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Dictionary::createMarkerMap(cv::Size,int,int,std::vector< int,std::allocator< int > > const &,bool)\n" + " aruco::Dictionary::createMarkerMap(cv::Size,int,int,std::vector< int,std::allocator< int > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_loadPredefined__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary::DICT_TYPES arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Dictionary result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_loadPredefined",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Dictionary_loadPredefined" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); + } + arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); + result = aruco::Dictionary::loadPredefined(arg1); + resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_loadPredefined__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::Dictionary result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_loadPredefined",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_loadPredefined" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::Dictionary::loadPredefined(arg1); + resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_loadPredefined(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Dictionary_loadPredefined__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Dictionary_loadPredefined__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_loadPredefined'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Dictionary::loadPredefined(aruco::Dictionary::DICT_TYPES)\n" + " aruco::Dictionary::loadPredefined(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_loadFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::Dictionary result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_loadFromFile",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_loadFromFile" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::Dictionary::loadFromFile(arg1); + resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::Dictionary result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_load",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_load" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::Dictionary::load(arg1); + resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_computeDictionaryDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + uint64_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_computeDictionaryDistance",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__Dictionary, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_computeDictionaryDistance" "', argument " "1"" of type '" "aruco::Dictionary const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_computeDictionaryDistance" "', argument " "1"" of type '" "aruco::Dictionary const &""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + result = aruco::Dictionary::computeDictionaryDistance((aruco::Dictionary const &)*arg1); + resultobj = SWIG_NewPointerObj((new uint64_t(static_cast< const uint64_t& >(result))), SWIGTYPE_p_uint64_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::Dictionary::DICT_TYPES result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getTypeFromString",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_getTypeFromString" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (aruco::Dictionary::DICT_TYPES)aruco::Dictionary::getTypeFromString(arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getTypeString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary::DICT_TYPES arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getTypeString",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Dictionary_getTypeString" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); + } + arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); + result = aruco::Dictionary::getTypeString(arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_isPredefinedDictinaryString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_isPredefinedDictinaryString",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_isPredefinedDictinaryString" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (bool)aruco::Dictionary::isPredefinedDictinaryString(arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getDicTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< std::vector< std::string,std::allocator< std::string > > > result; + + if (!PyArg_ParseTuple(args,(char *)":Dictionary_getDicTypes")) SWIG_fail; + result = aruco::Dictionary::getDicTypes(); + resultobj = SWIG_NewPointerObj((new std::vector< std::string,std::allocator< std::string > >(static_cast< const std::vector< std::string,std::allocator< std::string > >& >(result))), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Dictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Dictionary")) SWIG_fail; + result = (aruco::Dictionary *)new aruco::Dictionary(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Dictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Dictionary",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dictionary" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Dictionary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Dictionary, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Point2fVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_iterator" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_cv_Point2f_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___nonzero__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (bool)std_vector_Sl_cv_Point2f_Sg____nonzero__((std::vector< cv::Point2f > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___bool__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (bool)std_vector_Sl_cv_Point2f_Sg____bool__((std::vector< cv::Point2f > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___len__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = std_vector_Sl_cv_Point2f_Sg____len__((std::vector< cv::Point2f > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::difference_type arg2 ; + std::vector< cv::Point2f >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___getslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___getslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___getslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); + try { + result = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)std_vector_Sl_cv_Point2f_Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::difference_type arg2 ; + std::vector< cv::Point2f >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___setslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___setslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); + try { + std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_0(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::difference_type arg2 ; + std::vector< cv::Point2f >::difference_type arg3 ; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Point2fVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___setslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___setslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); + { + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Point2fVec___setslice__" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec___setslice__" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Point2fVec___setslice____SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point2fVec___setslice____SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::__setslice__(std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f >::difference_type)\n" + " std::vector< cv::Point2f >::__setslice__(std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::difference_type arg2 ; + std::vector< cv::Point2f >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___delslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___delslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___delslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); + try { + std_vector_Sl_cv_Point2f_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___delitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___delitem__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); + try { + std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___getitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + { + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___setitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___delitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_Point2fVec___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Point2fVec___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::__delitem__(std::vector< cv::Point2f >::difference_type)\n" + " std::vector< cv::Point2f >::__delitem__(PySliceObject *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< cv::Point2f >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___getitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___getitem__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); + try { + result = (std::vector< cv::Point2f >::value_type *) &std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_1((std::vector< cv::Point2f > const *)arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Point2f, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_Point2fVec___getitem____SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Point2fVec___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::__getitem__(PySliceObject *)\n" + " std::vector< cv::Point2f >::__getitem__(std::vector< cv::Point2f >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::difference_type arg2 ; + std::vector< cv::Point2f >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___setitem__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); + try { + std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_2(arg1,arg2,(cv::Point2f const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_Point2fVec___setitem____SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point2fVec___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Point2f, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point2fVec___setitem____SWIG_2(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::__setitem__(PySliceObject *,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)\n" + " std::vector< cv::Point2f >::__setitem__(PySliceObject *)\n" + " std::vector< cv::Point2f >::__setitem__(std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_pop" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + try { + result = std_vector_Sl_cv_Point2f_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + { + PyObject* array = point2f_to_array(&result); + if (array == NULL) + SWIG_fail; + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_append" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point2fVec_append" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_append" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp2); + std_vector_Sl_cv_Point2f_Sg__append(arg1,(cv::Point2f const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Point2fVec")) SWIG_fail; + result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Point2fVec",&obj0)) SWIG_fail; + { + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >((std::vector< cv::Point2f > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_empty" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (bool)((std::vector< cv::Point2f > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_size" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = ((std::vector< cv::Point2f > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_swap" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point2fVec_swap" "', argument " "2"" of type '" "std::vector< cv::Point2f > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_swap" "', argument " "2"" of type '" "std::vector< cv::Point2f > &""'"); + } + arg2 = reinterpret_cast< std::vector< cv::Point2f > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_begin" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_end" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_rbegin" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_rend" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_clear" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::allocator< cv::Point2f > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_get_allocator" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = ((std::vector< cv::Point2f > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< cv::Point2f >::allocator_type(static_cast< const std::vector< cv::Point2f >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cv__Point2f_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Point2fVec",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f >::size_type""'"); + } + arg1 = static_cast< std::vector< cv::Point2f >::size_type >(val1); + result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_pop_back" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_resize" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_resize" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< cv::Point2f >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_erase" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } + } + result = std_vector_Sl_cv_Point2f_Sg__erase__SWIG_0(arg1,arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::iterator arg2 ; + std::vector< cv::Point2f >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< cv::Point2f >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_erase" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "3"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "3"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } + } + result = std_vector_Sl_cv_Point2f_Sg__erase__SWIG_1(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_Point2fVec_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_Point2fVec_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::erase(std::vector< cv::Point2f >::iterator)\n" + " std::vector< cv::Point2f >::erase(std::vector< cv::Point2f >::iterator,std::vector< cv::Point2f >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f >::size_type arg1 ; + std::vector< cv::Point2f >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< cv::Point2f > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_Point2fVec",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f >::size_type""'"); + } + arg1 = static_cast< std::vector< cv::Point2f >::size_type >(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Point2fVec" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Point2fVec" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp2); + result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >(arg1,(std::vector< cv::Point2f >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Point2fVec(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_Point2fVec__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Point2fVec__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Point2fVec__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Point2f, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Point2fVec__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Point2fVec'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::vector()\n" + " std::vector< cv::Point2f >::vector(std::vector< cv::Point2f > const &)\n" + " std::vector< cv::Point2f >::vector(std::vector< cv::Point2f >::size_type)\n" + " std::vector< cv::Point2f >::vector(std::vector< cv::Point2f >::size_type,std::vector< cv::Point2f >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_push_back" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point2fVec_push_back" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_push_back" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp2); + (arg1)->push_back((std::vector< cv::Point2f >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_front" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (std::vector< cv::Point2f >::value_type *) &((std::vector< cv::Point2f > const *)arg1)->front(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Point2f, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_back" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = (std::vector< cv::Point2f >::value_type *) &((std::vector< cv::Point2f > const *)arg1)->back(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Point2f, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::size_type arg2 ; + std::vector< cv::Point2f >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_assign" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_assign" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec_assign" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_assign" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); + (arg1)->assign(arg2,(std::vector< cv::Point2f >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::size_type arg2 ; + std::vector< cv::Point2f >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_resize" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_resize" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec_resize" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_resize" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); + (arg1)->resize(arg2,(std::vector< cv::Point2f >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Point2fVec_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Point2f, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point2fVec_resize__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::resize(std::vector< cv::Point2f >::size_type)\n" + " std::vector< cv::Point2f >::resize(std::vector< cv::Point2f >::size_type,std::vector< cv::Point2f >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::iterator arg2 ; + std::vector< cv::Point2f >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< cv::Point2f >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_insert" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec_insert" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_insert" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); + result = std_vector_Sl_cv_Point2f_Sg__insert__SWIG_0(arg1,arg2,(cv::Point2f const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::iterator arg2 ; + std::vector< cv::Point2f >::size_type arg3 ; + std::vector< cv::Point2f >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Point2fVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_insert" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec_insert" "', argument " "3"" of type '" "std::vector< cv::Point2f >::size_type""'"); + } + arg3 = static_cast< std::vector< cv::Point2f >::size_type >(val3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cv__Point2f, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Point2fVec_insert" "', argument " "4"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_insert" "', argument " "4"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); + } + arg4 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp4); + std_vector_Sl_cv_Point2f_Sg__insert__SWIG_1(arg1,arg2,arg3,(cv::Point2f const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Point2f, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point2fVec_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cv__Point2f, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point2fVec_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< cv::Point2f >::insert(std::vector< cv::Point2f >::iterator,std::vector< cv::Point2f >::value_type const &)\n" + " std::vector< cv::Point2f >::insert(std::vector< cv::Point2f >::iterator,std::vector< cv::Point2f >::size_type,std::vector< cv::Point2f >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + std::vector< cv::Point2f >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_reserve" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_reserve" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); + } + arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point2fVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point2f >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_capacity" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + result = ((std::vector< cv::Point2f > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Point2fVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Point2fVec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); + } + arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Point2fVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_MarkerVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_iterator" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___nonzero__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (bool)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____nonzero__((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___bool__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (bool)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____bool__((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___len__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____len__((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___getslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___getslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___getslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); + try { + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); + { + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerVec___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerVec___setslice____SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerVec___setslice____SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___delslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___delslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___delslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___delitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + { + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___setitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_MarkerVec___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerVec___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__delitem__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__delitem__(PySliceObject *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___getitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); + try { + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *) &std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_1((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_MarkerVec___getitem____SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerVec___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__getitem__(PySliceObject *)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__getitem__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___setitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); + try { + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_2(arg1,arg2,(aruco::Marker const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_MarkerVec___setitem____SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerVec___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerVec___setitem____SWIG_2(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setitem__(PySliceObject *,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setitem__(PySliceObject *)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setitem__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_pop" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + try { + result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type& >(result))), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_append" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerVec_append" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_append" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp2); + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__append(arg1,(aruco::Marker const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerVec")) SWIG_fail; + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerVec",&obj0)) SWIG_fail; + { + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_empty" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (bool)((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_size" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = ((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_swap" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerVec_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_begin" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_end" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_rbegin" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_rend" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_clear" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::allocator< aruco::Marker > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_get_allocator" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = ((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker,std::allocator< aruco::Marker > >::allocator_type(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_aruco__Marker_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerVec",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); + } + arg1 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val1); + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_pop_back" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } else { + swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } + } + result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_0(arg1,arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } else { + swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } else { + swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } + } + result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_1(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_MarkerVec_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_MarkerVec_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::erase(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::erase(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg1 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_MarkerVec",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); + } + arg1 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MarkerVec" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerVec" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp2); + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >(arg1,(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerVec(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_MarkerVec__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_MarkerVec__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MarkerVec__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MarkerVec__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerVec'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector()\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_push_back" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerVec_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp2); + (arg1)->push_back((std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_front" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *) &((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->front(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_back" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *) &((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->back(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_assign" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_assign" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); + (arg1)->assign(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); + (arg1)->resize(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerVec_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerVec_resize__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::resize(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::resize(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } else { + swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); + result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_0(arg1,arg2,(aruco::Marker const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg3 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } else { + swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerVec_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); + } + arg4 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp4); + std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_1(arg1,arg2,arg3,(aruco::Marker const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerVec_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerVec_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::insert(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n" + " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::insert(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_reserve" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_reserve" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_capacity" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + result = ((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerVec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_iterator" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_aruco_Marker3DInfo_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___nonzero__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (bool)std_vector_Sl_aruco_Marker3DInfo_Sg____nonzero__((std::vector< aruco::Marker3DInfo > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___bool__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (bool)std_vector_Sl_aruco_Marker3DInfo_Sg____bool__((std::vector< aruco::Marker3DInfo > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___len__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = std_vector_Sl_aruco_Marker3DInfo_Sg____len__((std::vector< aruco::Marker3DInfo > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::difference_type arg2 ; + std::vector< aruco::Marker3DInfo >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___getslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___getslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___getslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); + try { + result = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)std_vector_Sl_aruco_Marker3DInfo_Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::difference_type arg2 ; + std::vector< aruco::Marker3DInfo >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_0(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::difference_type arg2 ; + std::vector< aruco::Marker3DInfo >::difference_type arg3 ; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorMarker3DInfo___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); + { + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *ptr = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorMarker3DInfo___setslice____SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMarker3DInfo___setslice____SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::__setslice__(std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo >::difference_type)\n" + " std::vector< aruco::Marker3DInfo >::__setslice__(std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::difference_type arg2 ; + std::vector< aruco::Marker3DInfo >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___delslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___delslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___delslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + { + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *ptr = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___setitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + { + if (!PySlice_Check(obj1)) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); + } + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_VectorMarker3DInfo___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorMarker3DInfo___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::__delitem__(std::vector< aruco::Marker3DInfo >::difference_type)\n" + " std::vector< aruco::Marker3DInfo >::__delitem__(PySliceObject *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker3DInfo >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); + try { + result = (std::vector< aruco::Marker3DInfo >::value_type *) &std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_1((std::vector< aruco::Marker3DInfo > const *)arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_VectorMarker3DInfo___getitem____SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorMarker3DInfo___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::__getitem__(PySliceObject *)\n" + " std::vector< aruco::Marker3DInfo >::__getitem__(std::vector< aruco::Marker3DInfo >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::difference_type arg2 ; + std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); + try { + std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_2(arg1,arg2,(aruco::Marker3DInfo const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_VectorMarker3DInfo___setitem____SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMarker3DInfo___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMarker3DInfo___setitem____SWIG_2(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::__setitem__(PySliceObject *,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)\n" + " std::vector< aruco::Marker3DInfo >::__setitem__(PySliceObject *)\n" + " std::vector< aruco::Marker3DInfo >::__setitem__(std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_pop" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + try { + result = std_vector_Sl_aruco_Marker3DInfo_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker3DInfo >::value_type(static_cast< const std::vector< aruco::Marker3DInfo >::value_type& >(result))), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_append" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMarker3DInfo_append" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_append" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp2); + std_vector_Sl_aruco_Marker3DInfo_Sg__append(arg1,(aruco::Marker3DInfo const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_VectorMarker3DInfo")) SWIG_fail; + result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_VectorMarker3DInfo",&obj0)) SWIG_fail; + { + std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *ptr = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >((std::vector< aruco::Marker3DInfo > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_empty" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (bool)((std::vector< aruco::Marker3DInfo > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_size" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = ((std::vector< aruco::Marker3DInfo > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_swap" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMarker3DInfo_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo > &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_begin" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_end" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_rbegin" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_rend" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_clear" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::allocator< aruco::Marker3DInfo > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_get_allocator" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = ((std::vector< aruco::Marker3DInfo > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker3DInfo >::allocator_type(static_cast< const std::vector< aruco::Marker3DInfo >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_VectorMarker3DInfo",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); + } + arg1 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val1); + result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_pop_back" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker3DInfo >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } + } + result = std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_0(arg1,arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::iterator arg2 ; + std::vector< aruco::Marker3DInfo >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< aruco::Marker3DInfo >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } + } + result = std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_1(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_VectorMarker3DInfo_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_VectorMarker3DInfo_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::erase(std::vector< aruco::Marker3DInfo >::iterator)\n" + " std::vector< aruco::Marker3DInfo >::erase(std::vector< aruco::Marker3DInfo >::iterator,std::vector< aruco::Marker3DInfo >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo >::size_type arg1 ; + std::vector< aruco::Marker3DInfo >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker3DInfo > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorMarker3DInfo",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); + } + arg1 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMarker3DInfo" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMarker3DInfo" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp2); + result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >(arg1,(std::vector< aruco::Marker3DInfo >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_VectorMarker3DInfo__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_VectorMarker3DInfo__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMarker3DInfo__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMarker3DInfo__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorMarker3DInfo'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::vector()\n" + " std::vector< aruco::Marker3DInfo >::vector(std::vector< aruco::Marker3DInfo > const &)\n" + " std::vector< aruco::Marker3DInfo >::vector(std::vector< aruco::Marker3DInfo >::size_type)\n" + " std::vector< aruco::Marker3DInfo >::vector(std::vector< aruco::Marker3DInfo >::size_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_push_back" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMarker3DInfo_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp2); + (arg1)->push_back((std::vector< aruco::Marker3DInfo >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_front" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (std::vector< aruco::Marker3DInfo >::value_type *) &((std::vector< aruco::Marker3DInfo > const *)arg1)->front(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_back" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = (std::vector< aruco::Marker3DInfo >::value_type *) &((std::vector< aruco::Marker3DInfo > const *)arg1)->back(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::size_type arg2 ; + std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_assign" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_assign" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); + (arg1)->assign(arg2,(std::vector< aruco::Marker3DInfo >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::size_type arg2 ; + std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); + (arg1)->resize(arg2,(std::vector< aruco::Marker3DInfo >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_VectorMarker3DInfo_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMarker3DInfo_resize__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::resize(std::vector< aruco::Marker3DInfo >::size_type)\n" + " std::vector< aruco::Marker3DInfo >::resize(std::vector< aruco::Marker3DInfo >::size_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::iterator arg2 ; + std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< aruco::Marker3DInfo >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); + result = std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_0(arg1,arg2,(aruco::Marker3DInfo const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::iterator arg2 ; + std::vector< aruco::Marker3DInfo >::size_type arg3 ; + std::vector< aruco::Marker3DInfo >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorMarker3DInfo_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); + } + arg3 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMarker3DInfo_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); + } + arg4 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp4); + std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_1(arg1,arg2,arg3,(aruco::Marker3DInfo const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMarker3DInfo_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMarker3DInfo_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< aruco::Marker3DInfo >::insert(std::vector< aruco::Marker3DInfo >::iterator,std::vector< aruco::Marker3DInfo >::value_type const &)\n" + " std::vector< aruco::Marker3DInfo >::insert(std::vector< aruco::Marker3DInfo >::iterator,std::vector< aruco::Marker3DInfo >::size_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + std::vector< aruco::Marker3DInfo >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_reserve" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_reserve" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker3DInfo >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_capacity" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + result = ((std::vector< aruco::Marker3DInfo > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorMarker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorMarker3DInfo",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorMarker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Marker_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_id_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_id_set" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_id_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->id = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_id_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_id_get" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (int) ((arg1)->id); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_ssize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_ssize_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_ssize_set" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_ssize_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + if (arg1) (arg1)->ssize = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_ssize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_ssize_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_ssize_get" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (float) ((arg1)->ssize); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_Rvec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + cv::Mat arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + cv::Mat *mat2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_Rvec_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Rvec_set" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + if (arg1) (arg1)->Rvec = arg2; + resultobj = SWIG_Py_Void(); + { + + } + { + if (mat2 != NULL) + delete mat2; + } + return resultobj; +fail: + { + if (mat2 != NULL) + delete mat2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_Rvec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_Rvec_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Rvec_get" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = ((arg1)->Rvec); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_Tvec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + cv::Mat arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + cv::Mat *mat2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_Tvec_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Tvec_set" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + if (arg1) (arg1)->Tvec = arg2; + resultobj = SWIG_Py_Void(); + { + + } + { + if (mat2 != NULL) + delete mat2; + } + return resultobj; +fail: + { + if (mat2 != NULL) + delete mat2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_Tvec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_Tvec_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Tvec_get" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = ((arg1)->Tvec); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_dict_info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_dict_info_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_dict_info_set" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_dict_info_set" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_dict_info_set" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + if (arg1) (arg1)->dict_info = *arg2; + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_dict_info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_dict_info_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_dict_info_get" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (std::string *) & ((arg1)->dict_info); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Marker")) SWIG_fail; + result = (aruco::Marker *)new aruco::Marker(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Marker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Marker",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Marker" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + result = (aruco::Marker *)new aruco::Marker(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Marker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Marker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Marker" "', argument " "1"" of type '" "aruco::Marker const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Marker" "', argument " "1"" of type '" "aruco::Marker const &""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (aruco::Marker *)new aruco::Marker((aruco::Marker const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg1 = 0 ; + int arg2 ; + int res1 = SWIG_OLDOBJ ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::Marker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_Marker",&obj0,&obj1)) SWIG_fail; + { + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + arg1 = ptr; + } + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Marker" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (aruco::Marker *)new aruco::Marker((std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + aruco::Marker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Marker",&obj0)) SWIG_fail; + { + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); + } + arg1 = ptr; + } + result = (aruco::Marker *)new aruco::Marker((std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_Marker__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Marker__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Marker__SWIG_1(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Marker__SWIG_4(self, args); + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Marker__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Marker'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Marker::Marker()\n" + " aruco::Marker::Marker(int)\n" + " aruco::Marker::Marker(aruco::Marker const &)\n" + " aruco::Marker::Marker(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &,int)\n" + " aruco::Marker::Marker(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_Marker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Marker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Marker" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_isValid",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_isValid" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (bool)((aruco::Marker const *)arg1)->isValid(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_isPoseValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_isPoseValid",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_isPoseValid" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (bool)((aruco::Marker const *)arg1)->isPoseValid(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + cv::Mat *arg2 = 0 ; + cv::Scalar arg3 ; + int arg4 ; + bool arg5 ; + bool arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + bool val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Marker_draw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + { + arg3 = *array_to_scalar(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_draw" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Marker_draw" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + ecode6 = SWIG_AsVal_bool(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Marker_draw" "', argument " "6"" of type '" "bool""'"); + } + arg6 = static_cast< bool >(val6); + ((aruco::Marker const *)arg1)->draw(*arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + cv::Mat *arg2 = 0 ; + cv::Scalar arg3 ; + int arg4 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:Marker_draw",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + { + arg3 = *array_to_scalar(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_draw" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Marker_draw" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + ((aruco::Marker const *)arg1)->draw(*arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + cv::Mat *arg2 = 0 ; + cv::Scalar arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Marker_draw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + { + arg3 = *array_to_scalar(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_draw" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ((aruco::Marker const *)arg1)->draw(*arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + cv::Mat *arg2 = 0 ; + cv::Scalar arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_draw",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + { + arg3 = *array_to_scalar(obj2); + if (&arg3 == NULL) + SWIG_fail; + } + ((aruco::Marker const *)arg1)->draw(*arg2,arg3); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + cv::Mat *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_draw",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + ((aruco::Marker const *)arg1)->draw(*arg2); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_draw(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 6) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + return _wrap_Marker_draw__SWIG_4(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + return _wrap_Marker_draw__SWIG_3(self, args); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Marker_draw__SWIG_2(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Marker_draw__SWIG_1(self, args); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Marker_draw__SWIG_0(self, args); + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_draw'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Marker::draw(cv::Mat &,cv::Scalar,int,bool,bool) const\n" + " aruco::Marker::draw(cv::Mat &,cv::Scalar,int,bool) const\n" + " aruco::Marker::draw(cv::Mat &,cv::Scalar,int) const\n" + " aruco::Marker::draw(cv::Mat &,cv::Scalar) const\n" + " aruco::Marker::draw(cv::Mat &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + float arg2 ; + aruco::CameraParameters *arg3 = 0 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_calculateExtrinsics" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + (arg1)->calculateExtrinsics(arg2,(aruco::CameraParameters const &)*arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + float arg2 ; + aruco::CameraParameters *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + (arg1)->calculateExtrinsics(arg2,(aruco::CameraParameters const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + float arg2 ; + cv::Mat arg3 ; + cv::Mat arg4 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + cv::Mat *mat3 ; + cv::Mat *mat4 ; + bool val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + { + mat3 = array_to_mat(obj2); + if (mat3 == NULL) + SWIG_fail; + arg3 = *mat3; + } + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Marker_calculateExtrinsics" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + (arg1)->calculateExtrinsics(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + { + + } + { + + } + { + if (mat3 != NULL) + delete mat3; + } + { + if (mat4 != NULL) + delete mat4; + } + return resultobj; +fail: + { + if (mat3 != NULL) + delete mat3; + } + { + if (mat4 != NULL) + delete mat4; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + float arg2 ; + cv::Mat arg3 ; + cv::Mat arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + cv::Mat *mat3 ; + cv::Mat *mat4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + { + mat3 = array_to_mat(obj2); + if (mat3 == NULL) + SWIG_fail; + arg3 = *mat3; + } + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + (arg1)->calculateExtrinsics(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + { + + } + { + + } + { + if (mat3 != NULL) + delete mat3; + } + { + if (mat4 != NULL) + delete mat4; + } + return resultobj; +fail: + { + if (mat3 != NULL) + delete mat3; + } + { + if (mat4 != NULL) + delete mat4; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + float arg2 ; + cv::Mat arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + cv::Mat *mat3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + { + mat3 = array_to_mat(obj2); + if (mat3 == NULL) + SWIG_fail; + arg3 = *mat3; + } + (arg1)->calculateExtrinsics(arg2,arg3); + resultobj = SWIG_Py_Void(); + { + + } + { + if (mat3 != NULL) + delete mat3; + } + return resultobj; +fail: + { + if (mat3 != NULL) + delete mat3; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Marker_calculateExtrinsics__SWIG_1(self, args); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + return _wrap_Marker_calculateExtrinsics__SWIG_4(self, args); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + { + _v = is_array(argv[3]) || PySequence_Check(argv[3]); + } + if (_v) { + return _wrap_Marker_calculateExtrinsics__SWIG_3(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Marker_calculateExtrinsics__SWIG_0(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + _v = is_array(argv[2]) || PySequence_Check(argv[2]); + } + if (_v) { + { + _v = is_array(argv[3]) || PySequence_Check(argv[3]); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Marker_calculateExtrinsics__SWIG_2(self, args); + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_calculateExtrinsics'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Marker::calculateExtrinsics(float,aruco::CameraParameters const &,bool)\n" + " aruco::Marker::calculateExtrinsics(float,aruco::CameraParameters const &)\n" + " aruco::Marker::calculateExtrinsics(float,cv::Mat,cv::Mat,bool)\n" + " aruco::Marker::calculateExtrinsics(float,cv::Mat,cv::Mat)\n" + " aruco::Marker::calculateExtrinsics(float,cv::Mat)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Marker_glGetModelViewMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + double *arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_glGetModelViewMatrix",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_glGetModelViewMatrix" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_glGetModelViewMatrix" "', argument " "2"" of type '" "double [16]""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + (arg1)->glGetModelViewMatrix(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_OgreGetPoseParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + double *arg2 ; + double *arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_OgreGetPoseParameters",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_OgreGetPoseParameters" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_OgreGetPoseParameters" "', argument " "2"" of type '" "double [3]""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Marker_OgreGetPoseParameters" "', argument " "3"" of type '" "double [4]""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + (arg1)->OgreGetPoseParameters(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Point2f result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_getCenter",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getCenter" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = ((aruco::Marker const *)arg1)->getCenter(); + { + PyObject* array = point2f_to_array(&result); + if (array == NULL) + SWIG_fail; + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_getPerimeter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_getPerimeter",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getPerimeter" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (float)((aruco::Marker const *)arg1)->getPerimeter(); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_getArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_getArea",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getArea" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (float)((aruco::Marker const *)arg1)->getArea(); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + aruco::Marker *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker___eq__" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker___eq__" "', argument " "2"" of type '" "aruco::Marker const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker___eq__" "', argument " "2"" of type '" "aruco::Marker const &""'"); + } + arg2 = reinterpret_cast< aruco::Marker * >(argp2); + result = (bool)((aruco::Marker const *)arg1)->operator ==((aruco::Marker const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_copyTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + aruco::Marker *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_copyTo",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_copyTo" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_copyTo" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_copyTo" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + arg2 = reinterpret_cast< aruco::Marker * >(argp2); + ((aruco::Marker const *)arg1)->copyTo(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_toStream" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + ((aruco::Marker const *)arg1)->toStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_fromStream" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + (arg1)->fromStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_get3DPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + float arg1 ; + float val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + vector< cv::Point3f > result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_get3DPoints",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_float(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Marker_get3DPoints" "', argument " "1"" of type '" "float""'"); + } + arg1 = static_cast< float >(val1); + result = aruco::Marker::get3DPoints(arg1); + resultobj = SWIG_NewPointerObj((new vector< cv::Point3f >(static_cast< const vector< cv::Point3f >& >(result))), SWIGTYPE_p_vectorT_cv__Point3f_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_get3DPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + vector< cv::Point3f > result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_get3DPoints",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_get3DPoints" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = ((aruco::Marker const *)arg1)->get3DPoints(); + resultobj = SWIG_NewPointerObj((new vector< cv::Point3f >(static_cast< const vector< cv::Point3f >& >(result))), SWIGTYPE_p_vectorT_cv__Point3f_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_get3DPoints(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Marker_get3DPoints__SWIG_1(self, args); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_float(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Marker_get3DPoints__SWIG_0(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_get3DPoints'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Marker::get3DPoints(float)\n" + " aruco::Marker::get3DPoints() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Marker___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Point2f result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker___getitem__" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker___getitem__" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = aruco_Marker___getitem__(arg1,arg2); + { + PyObject* array = point2f_to_array(&result); + if (array == NULL) + SWIG_fail; + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Marker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DM_NORMAL_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *module; + PyObject *d; + if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; + d = PyModule_GetDict(module); + if (!d) return NULL; + SWIG_Python_SetConstant(d, "DM_NORMAL",SWIG_From_int(static_cast< int >(aruco::DM_NORMAL))); + return SWIG_Py_Void(); +} + + +SWIGINTERN PyObject *DM_FAST_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *module; + PyObject *d; + if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; + d = PyModule_GetDict(module); + if (!d) return NULL; + SWIG_Python_SetConstant(d, "DM_FAST",SWIG_From_int(static_cast< int >(aruco::DM_FAST))); + return SWIG_Py_Void(); +} + + +SWIGINTERN PyObject *DM_VIDEO_FAST_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *module; + PyObject *d; + if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; + d = PyModule_GetDict(module); + if (!d) return NULL; + SWIG_Python_SetConstant(d, "DM_VIDEO_FAST",SWIG_From_int(static_cast< int >(aruco::DM_VIDEO_FAST))); + return SWIG_Py_Void(); +} + + +SWIGINTERN PyObject *THRES_ADAPTIVE_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *module; + PyObject *d; + if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; + d = PyModule_GetDict(module); + if (!d) return NULL; + SWIG_Python_SetConstant(d, "THRES_ADAPTIVE",SWIG_From_int(static_cast< int >(aruco::THRES_ADAPTIVE))); + return SWIG_Py_Void(); +} + + +SWIGINTERN PyObject *THRES_AUTO_FIXED_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *module; + PyObject *d; + if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; + d = PyModule_GetDict(module); + if (!d) return NULL; + SWIG_Python_SetConstant(d, "THRES_AUTO_FIXED",SWIG_From_int(static_cast< int >(aruco::THRES_AUTO_FIXED))); + return SWIG_Py_Void(); +} + + +SWIGINTERN PyObject *_wrap_Params_maxThreads_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_maxThreads_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_maxThreads_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_maxThreads_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->maxThreads = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_maxThreads_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_maxThreads_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_maxThreads_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->maxThreads); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_borderDistThres_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_borderDistThres_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_borderDistThres_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_borderDistThres_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + if (arg1) (arg1)->borderDistThres = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_borderDistThres_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_borderDistThres_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_borderDistThres_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (float) ((arg1)->borderDistThres); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_lowResMarkerSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_lowResMarkerSize_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_lowResMarkerSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_lowResMarkerSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->lowResMarkerSize = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_lowResMarkerSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_lowResMarkerSize_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_lowResMarkerSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->lowResMarkerSize); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_minSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_minSize_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_minSize_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + if (arg1) (arg1)->minSize = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_minSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_minSize_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (float) ((arg1)->minSize); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_minSize_pix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_minSize_pix_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_pix_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_minSize_pix_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->minSize_pix = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_minSize_pix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_minSize_pix_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_pix_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->minSize_pix); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_enclosedMarker_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_enclosedMarker_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_enclosedMarker_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_enclosedMarker_set" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + if (arg1) (arg1)->enclosedMarker = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_enclosedMarker_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_enclosedMarker_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_enclosedMarker_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (bool) ((arg1)->enclosedMarker); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + aruco::ThresMethod arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:Params_setThresholdMethod",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); + } + arg2 = static_cast< aruco::ThresMethod >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setThresholdMethod" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Params_setThresholdMethod" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Params_setThresholdMethod" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->setThresholdMethod(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + aruco::ThresMethod arg2 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Params_setThresholdMethod",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); + } + arg2 = static_cast< aruco::ThresMethod >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setThresholdMethod" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Params_setThresholdMethod" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->setThresholdMethod(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + aruco::ThresMethod arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Params_setThresholdMethod",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); + } + arg2 = static_cast< aruco::ThresMethod >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setThresholdMethod" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + (arg1)->setThresholdMethod(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + aruco::ThresMethod arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_setThresholdMethod",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); + } + arg2 = static_cast< aruco::ThresMethod >(val2); + (arg1)->setThresholdMethod(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setThresholdMethod(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Params_setThresholdMethod__SWIG_3(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Params_setThresholdMethod__SWIG_2(self, args); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Params_setThresholdMethod__SWIG_1(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Params_setThresholdMethod__SWIG_0(self, args); + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Params_setThresholdMethod'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Params::setThresholdMethod(aruco::ThresMethod,int,int,int)\n" + " aruco::Params::setThresholdMethod(aruco::ThresMethod,int,int)\n" + " aruco::Params::setThresholdMethod(aruco::ThresMethod,int)\n" + " aruco::Params::setThresholdMethod(aruco::ThresMethod)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Params__thresMethod_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + aruco::ThresMethod arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params__thresMethod_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__thresMethod_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__thresMethod_set" "', argument " "2"" of type '" "aruco::ThresMethod""'"); + } + arg2 = static_cast< aruco::ThresMethod >(val2); + if (arg1) (arg1)->_thresMethod = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__thresMethod_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::ThresMethod result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params__thresMethod_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__thresMethod_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (aruco::ThresMethod) ((arg1)->_thresMethod); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_NAttemptsAutoThresFix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_NAttemptsAutoThresFix_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_NAttemptsAutoThresFix_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_NAttemptsAutoThresFix_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->NAttemptsAutoThresFix = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_NAttemptsAutoThresFix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_NAttemptsAutoThresFix_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_NAttemptsAutoThresFix_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->NAttemptsAutoThresFix); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params__AdaptiveThresWindowSize_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__AdaptiveThresWindowSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->_AdaptiveThresWindowSize = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params__AdaptiveThresWindowSize_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->_AdaptiveThresWindowSize); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__ThresHold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params__ThresHold_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ThresHold_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__ThresHold_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->_ThresHold = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__ThresHold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params__ThresHold_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ThresHold_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->_ThresHold); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_range_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params__AdaptiveThresWindowSize_range_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_range_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__AdaptiveThresWindowSize_range_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->_AdaptiveThresWindowSize_range = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_range_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params__AdaptiveThresWindowSize_range_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_range_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->_AdaptiveThresWindowSize_range); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__markerWarpPixSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params__markerWarpPixSize_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__markerWarpPixSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__markerWarpPixSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->_markerWarpPixSize = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__markerWarpPixSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params__markerWarpPixSize_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__markerWarpPixSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (int) ((arg1)->_markerWarpPixSize); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__autoSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params__autoSize_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__autoSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__autoSize_set" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + if (arg1) (arg1)->_autoSize = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__autoSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params__autoSize_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__autoSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (bool) ((arg1)->_autoSize); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__ts_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params__ts_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ts_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__ts_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + if (arg1) (arg1)->_ts = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params__ts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params__ts_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ts_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (float) ((arg1)->_ts); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setAutoSizeSpeedUp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + bool arg2 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Params_setAutoSizeSpeedUp",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setAutoSizeSpeedUp(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setAutoSizeSpeedUp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_setAutoSizeSpeedUp",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->setAutoSizeSpeedUp(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_setAutoSizeSpeedUp(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Params_setAutoSizeSpeedUp__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Params_setAutoSizeSpeedUp__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Params_setAutoSizeSpeedUp'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Params::setAutoSizeSpeedUp(bool,float)\n" + " aruco::Params::setAutoSizeSpeedUp(bool)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Params_getAutoSizeSpeedUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_getAutoSizeSpeedUp",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_getAutoSizeSpeedUp" "', argument " "1"" of type '" "aruco::Params const *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (bool)((aruco::Params const *)arg1)->getAutoSizeSpeedUp(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_pyrfactor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Params_pyrfactor_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_pyrfactor_set" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_pyrfactor_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + if (arg1) (arg1)->pyrfactor = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Params_pyrfactor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Params_pyrfactor_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_pyrfactor_get" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + result = (float) ((arg1)->pyrfactor); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Params")) SWIG_fail; + result = (aruco::Params *)new aruco::Params(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Params, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Params *arg1 = (aruco::Params *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Params",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Params" "', argument " "1"" of type '" "aruco::Params *""'"); + } + arg1 = reinterpret_cast< aruco::Params * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Params_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Params, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_MarkerCandidate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerCandidate *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerCandidate")) SWIG_fail; + result = (aruco::MarkerCandidate *)new aruco::MarkerCandidate(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerCandidate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::MarkerCandidate *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerCandidate",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__Marker, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::Marker const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::Marker const &""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (aruco::MarkerCandidate *)new aruco::MarkerCandidate((aruco::Marker const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerCandidate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerCandidate *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::MarkerCandidate *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerCandidate",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::MarkerCandidate const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::MarkerCandidate const &""'"); + } + arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); + result = (aruco::MarkerCandidate *)new aruco::MarkerCandidate((aruco::MarkerCandidate const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerCandidate(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_MarkerCandidate__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__MarkerCandidate, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MarkerCandidate__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MarkerCandidate__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerCandidate'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerCandidate::MarkerCandidate()\n" + " aruco::MarkerCandidate::MarkerCandidate(aruco::Marker const &)\n" + " aruco::MarkerCandidate::MarkerCandidate(aruco::MarkerCandidate const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerCandidate_contour_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; + vector< cv::Point > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerCandidate_contour_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_contour_set" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_cv__Point_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerCandidate_contour_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerCandidate_contour_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); + } else { + vector< cv::Point > * temp = reinterpret_cast< vector< cv::Point > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->contour = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerCandidate_contour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + vector< cv::Point > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerCandidate_contour_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_contour_get" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); + result = ((arg1)->contour); + resultobj = SWIG_NewPointerObj((new vector< cv::Point >(static_cast< const vector< cv::Point >& >(result))), SWIGTYPE_p_vectorT_cv__Point_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerCandidate_idx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerCandidate_idx_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_idx_set" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerCandidate_idx_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->idx = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerCandidate_idx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerCandidate_idx_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_idx_get" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); + result = (int) ((arg1)->idx); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerCandidate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerCandidate",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerCandidate" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerCandidate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerCandidate, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerDetector")) SWIG_fail; + result = (aruco::MarkerDetector *)new aruco::MarkerDetector(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + float arg2 ; + int val1 ; + int ecode1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::MarkerDetector *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_MarkerDetector",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkerDetector" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + aruco::MarkerDetector *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerDetector",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + float arg2 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::MarkerDetector *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_MarkerDetector",&obj0,&obj1)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkerDetector" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::MarkerDetector *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerDetector",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerDetector(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_MarkerDetector__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_MarkerDetector__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MarkerDetector__SWIG_4(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_MarkerDetector__SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_MarkerDetector__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerDetector'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::MarkerDetector()\n" + " aruco::MarkerDetector::MarkerDetector(int,float)\n" + " aruco::MarkerDetector::MarkerDetector(int)\n" + " aruco::MarkerDetector::MarkerDetector(std::string,float)\n" + " aruco::MarkerDetector::MarkerDetector(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerDetector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerDetector",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerDetector" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDetectionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::DetectionMode arg2 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDetectionMode",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDetectionMode" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDetectionMode" "', argument " "2"" of type '" "aruco::DetectionMode""'"); + } + arg2 = static_cast< aruco::DetectionMode >(val2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDetectionMode" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setDetectionMode(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDetectionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::DetectionMode arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDetectionMode",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDetectionMode" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDetectionMode" "', argument " "2"" of type '" "aruco::DetectionMode""'"); + } + arg2 = static_cast< aruco::DetectionMode >(val2); + (arg1)->setDetectionMode(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDetectionMode(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDetectionMode__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDetectionMode__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_setDetectionMode'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::setDetectionMode(aruco::DetectionMode,float)\n" + " aruco::MarkerDetector::setDetectionMode(aruco::DetectionMode)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getDetectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::DetectionMode result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getDetectionMode",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getDetectionMode" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = (aruco::DetectionMode)(arg1)->getDetectionMode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_detect",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + result = (arg1)->detect((cv::Mat const &)*arg2); + resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + float arg4 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerDetector_detect" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + result = (arg1)->detect((cv::Mat const &)*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); + resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + float arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + result = (arg1)->detect((cv::Mat const &)*arg2,(aruco::CameraParameters const &)*arg3,arg4); + resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + aruco::CameraParameters arg4 ; + float arg5 ; + bool arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + float val5 ; + int ecode5 = 0 ; + bool val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); + } else { + aruco::CameraParameters * temp = reinterpret_cast< aruco::CameraParameters * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + ecode5 = SWIG_AsVal_float(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerDetector_detect" "', argument " "5"" of type '" "float""'"); + } + arg5 = static_cast< float >(val5); + ecode6 = SWIG_AsVal_bool(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MarkerDetector_detect" "', argument " "6"" of type '" "bool""'"); + } + arg6 = static_cast< bool >(val6); + (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + aruco::CameraParameters arg4 ; + float arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + float val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); + } else { + aruco::CameraParameters * temp = reinterpret_cast< aruco::CameraParameters * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + ecode5 = SWIG_AsVal_float(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerDetector_detect" "', argument " "5"" of type '" "float""'"); + } + arg5 = static_cast< float >(val5); + (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + aruco::CameraParameters arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); + } else { + aruco::CameraParameters * temp = reinterpret_cast< aruco::CameraParameters * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4); + resultobj = SWIG_Py_Void(); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + cv::Mat arg4 ; + cv::Mat arg5 ; + float arg6 ; + bool arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + cv::Mat *mat4 ; + cv::Mat *mat5 ; + float val6 ; + int ecode6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + { + mat5 = array_to_mat(obj4); + if (mat5 == NULL) + SWIG_fail; + arg5 = *mat5; + } + ecode6 = SWIG_AsVal_float(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MarkerDetector_detect" "', argument " "6"" of type '" "float""'"); + } + arg6 = static_cast< float >(val6); + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MarkerDetector_detect" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + resultobj = SWIG_Py_Void(); + { + + } + { + + } + { + + } + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + cv::Mat arg4 ; + cv::Mat arg5 ; + float arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + cv::Mat *mat4 ; + cv::Mat *mat5 ; + float val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + { + mat5 = array_to_mat(obj4); + if (mat5 == NULL) + SWIG_fail; + arg5 = *mat5; + } + ecode6 = SWIG_AsVal_float(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MarkerDetector_detect" "', argument " "6"" of type '" "float""'"); + } + arg6 = static_cast< float >(val6); + (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + { + + } + { + + } + { + + } + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + cv::Mat arg4 ; + cv::Mat arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + cv::Mat *mat4 ; + cv::Mat *mat5 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + { + mat5 = array_to_mat(obj4); + if (mat5 == NULL) + SWIG_fail; + arg5 = *mat5; + } + (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + { + + } + { + + } + { + + } + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + cv::Mat arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + cv::Mat *mat4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4); + resultobj = SWIG_Py_Void(); + { + + } + { + + } + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + { + if (mat4 != NULL) + delete mat4; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_detect",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + } + arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + (arg1)->detect((cv::Mat const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_detect(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 7) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_10(self, args); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_5(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[3]) || PySequence_Check(argv[3]); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_9(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_2(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[3]) || PySequence_Check(argv[3]); + } + if (_v) { + { + _v = is_array(argv[4]) || PySequence_Check(argv[4]); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_8(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_4(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_1(self, args); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[3]) || PySequence_Check(argv[3]); + } + if (_v) { + { + _v = is_array(argv[4]) || PySequence_Check(argv[4]); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_7(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_3(self, args); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[3]) || PySequence_Check(argv[3]); + } + if (_v) { + { + _v = is_array(argv[4]) || PySequence_Check(argv[4]); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_6(self, args); + } + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_detect'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::detect(cv::Mat const &)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float,bool)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,aruco::CameraParameters,float,bool)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,aruco::CameraParameters,float)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,aruco::CameraParameters)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat,cv::Mat,float,bool)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat,cv::Mat,float)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat,cv::Mat)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Params result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = ((aruco::MarkerDetector const *)arg1)->getParameters(); + resultobj = SWIG_NewPointerObj((new aruco::Params(static_cast< const aruco::Params& >(result))), SWIGTYPE_p_aruco__Params, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Params *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = (aruco::Params *) &(arg1)->getParameters(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Params, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getParameters__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getParameters__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getParameters'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::getParameters() const\n" + " aruco::MarkerDetector::getParameters()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::string arg2 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setDictionary(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setDictionary(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + int arg2 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setDictionary(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setDictionary(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_3(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_2(self, args); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_setDictionary'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::setDictionary(std::string,float)\n" + " aruco::MarkerDetector::setDictionary(std::string)\n" + " aruco::MarkerDetector::setDictionary(int,float)\n" + " aruco::MarkerDetector::setDictionary(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + uint32_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_getThresholdedImage",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint32_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); + } else { + uint32_t * temp = reinterpret_cast< uint32_t * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (arg1)->getThresholdedImage(arg2); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getThresholdedImage",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = (arg1)->getThresholdedImage(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getThresholdedImage__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_uint32_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getThresholdedImage__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getThresholdedImage'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::getThresholdedImage(uint32_t)\n" + " aruco::MarkerDetector::getThresholdedImage()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Ptr< aruco::MarkerLabeler > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setMarkerLabeler",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); + } else { + cv::Ptr< aruco::MarkerLabeler > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerLabeler > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setMarkerLabeler(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getMarkerLabeler",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = (arg1)->getMarkerLabeler(); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getCandidates",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getCandidates" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = ((aruco::MarkerDetector const *)arg1)->getCandidates(); + resultobj = SWIG_NewPointerObj((new std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > >(static_cast< const std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_warp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Mat *arg2 = 0 ; + cv::Mat *arg3 = 0 ; + cv::Size arg4 ; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + uchar *data_ptr3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_warp",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_warp" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + { + arg3 = array_to_mat(obj2); + if (arg3 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr3 = arg3->data; + } + { + arg4 = *array_to_size(obj3); + if (&arg4 == NULL) + SWIG_fail; + } + { + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; + int res = swig::asptr(obj4, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_warp" "', argument " "5"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > >""'"); + } + arg5 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (bool)(arg1)->warp(*arg2,*arg3,arg4,arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + // check if the underlying data changed + if (data_ptr3 != arg3->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg3->rows, arg3->cols, arg3->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + { + if (arg3 != NULL) + delete arg3; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + { + if (arg3 != NULL) + delete arg3; + } + return NULL; +} + + +SWIGINTERN PyObject *MarkerDetector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerDetector, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary::DICT_TYPES arg1 ; + float arg2 ; + int val1 ; + int ecode1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); + } + arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = aruco::MarkerLabeler::create(arg1,arg2); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary::DICT_TYPES arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); + } + arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); + result = aruco::MarkerLabeler::create(arg1); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + std::string arg2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::MarkerLabeler::create(arg1,arg2); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::MarkerLabeler::create(arg1); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerLabeler_create__SWIG_1(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerLabeler_create__SWIG_3(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerLabeler_create__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerLabeler_create__SWIG_2(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerLabeler_create'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES,float)\n" + " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES)\n" + " aruco::MarkerLabeler::create(std::string,std::string)\n" + " aruco::MarkerLabeler::create(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + cv::Mat *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + std::string *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerLabeler_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_detect" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); + } + arg5 = reinterpret_cast< std::string * >(argp5); + result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_getBestInputSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getBestInputSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getBestInputSize" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + result = (int)(arg1)->getBestInputSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getNSubdivisions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getNSubdivisions" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + result = (int)((aruco::MarkerLabeler const *)arg1)->getNSubdivisions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getName" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + result = ((aruco::MarkerLabeler const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerLabeler",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerLabeler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerLabeler, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Marker3DInfo_points_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + std::vector< cv::Point3f,std::allocator< cv::Point3f > > *arg2 = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_points_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_points_set" "', argument " "2"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > > *""'"); + } + arg2 = reinterpret_cast< std::vector< cv::Point3f,std::allocator< cv::Point3f > > * >(argp2); + if (arg1) (arg1)->points = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_points_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point3f,std::allocator< cv::Point3f > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_points_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *)& ((arg1)->points); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_id_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_id_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->id = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_id_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = (int) ((arg1)->id); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Marker3DInfo")) SWIG_fail; + result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Marker3DInfo *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Marker3DInfo",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Marker3DInfo" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker3DInfo(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_Marker3DInfo__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Marker3DInfo__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Marker3DInfo'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Marker3DInfo::Marker3DInfo()\n" + " aruco::Marker3DInfo::Marker3DInfo(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::Marker3DInfo *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo___eq__" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); + } + arg2 = reinterpret_cast< aruco::Marker3DInfo * >(argp2); + result = (bool)(arg1)->operator ==((aruco::Marker3DInfo const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_getMarkerSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_getMarkerSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_getMarkerSize" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = (float)((aruco::Marker3DInfo const *)arg1)->getMarkerSize(); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Point3f result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_at",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_at" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_at" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + result = ((aruco::Marker3DInfo const *)arg1)->at(arg2); + resultobj = SWIG_NewPointerObj((new cv::Point3f(static_cast< const cv::Point3f& >(result))), SWIGTYPE_p_cv__Point3f, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + cv::Point3f *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_push_back" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point3f, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); + } + arg2 = reinterpret_cast< cv::Point3f * >(argp2); + (arg1)->push_back((cv::Point3f const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + size_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_size" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = ((aruco::Marker3DInfo const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_toStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + (arg1)->toStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_fromStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + (arg1)->fromStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Marker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Marker3DInfo",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Marker3DInfo" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Marker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker3DInfo, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerMap")) SWIG_fail; + result = (aruco::MarkerMap *)new aruco::MarkerMap(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::MarkerMap *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerMap",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerMap" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (aruco::MarkerMap *)new aruco::MarkerMap(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerMap(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_MarkerMap__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MarkerMap__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerMap'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMap::MarkerMap()\n" + " aruco::MarkerMap::MarkerMap(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInMeters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInMeters(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInPixels",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInPixels" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInPixels(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_convertToMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::MarkerMap result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_convertToMeters",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_convertToMeters" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_convertToMeters" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = (arg1)->convertToMeters(arg2); + resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + vector< aruco::Marker > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int,std::allocator< int > > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndices",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndices" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_aruco__Marker_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); + } + arg2 = reinterpret_cast< vector< aruco::Marker > * >(argp2); + result = ((aruco::MarkerMap const *)arg1)->getIndices((vector< aruco::Marker > const &)*arg2); + resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getMarker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::Marker3DInfo *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getMarker3DInfo",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (aruco::Marker3DInfo *) &((aruco::MarkerMap const *)arg1)->getMarker3DInfo(arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIndexOfMarkerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndexOfMarkerId",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)((aruco::MarkerMap const *)arg1)->getIndexOfMarkerId(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + vector< int > *arg2 = 0 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMap_getIdList",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + arg2 = reinterpret_cast< vector< int > * >(argp2); + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_getIdList" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + ((aruco::MarkerMap const *)arg1)->getIdList(*arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + vector< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIdList",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + arg2 = reinterpret_cast< vector< int > * >(argp2); + ((aruco::MarkerMap const *)arg1)->getIdList(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIdList(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerMap_getIdList__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerMap_getIdList__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getIdList'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMap::getIdList(vector< int > &,bool) const\n" + " aruco::MarkerMap::getIdList(vector< int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getImage",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getImage" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = ((aruco::MarkerMap const *)arg1)->getImage(arg2); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getImage",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = ((aruco::MarkerMap const *)arg1)->getImage(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getImage(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerMap_getImage__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerMap_getImage__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getImage'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMap::getImage(float) const\n" + " aruco::MarkerMap::getImage() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_saveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_saveToFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_saveToFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_saveToFile" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->saveToFile(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_readFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_readFromFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_readFromFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_readFromFile" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->readFromFile(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_calculateExtrinsics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; + float arg3 ; + cv::Mat arg4 ; + cv::Mat arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + float val3 ; + int ecode3 = 0 ; + cv::Mat *mat4 ; + cv::Mat *mat5 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + std::pair< cv::Mat,cv::Mat > result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerMap_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res2 = swig::asptr(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg2 = ptr; + } + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + { + mat5 = array_to_mat(obj4); + if (mat5 == NULL) + SWIG_fail; + arg5 = *mat5; + } + result = (arg1)->calculateExtrinsics((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2,arg3,arg4,arg5); + resultobj = SWIG_NewPointerObj((new std::pair< cv::Mat,cv::Mat >(static_cast< const std::pair< cv::Mat,cv::Mat >& >(result))), SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t, SWIG_POINTER_OWN | 0 ); + { + + } + { + + } + if (SWIG_IsNewObj(res2)) delete arg2; + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getDictionary",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getDictionary" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = ((aruco::MarkerMap const *)arg1)->getDictionary(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_setDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_setDictionary",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_setDictionary" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_setDictionary" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setDictionary(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_mInfoType_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_set" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_mInfoType_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->mInfoType = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_mInfoType_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_get" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = (int) ((arg1)->mInfoType); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_toStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + (arg1)->toStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_fromStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + (arg1)->fromStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMap",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMap" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMap, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + aruco::Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + float arg4 ; + float arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; + float val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + arg2 = reinterpret_cast< aruco::Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + ecode5 = SWIG_AsVal_float(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "5"" of type '" "float""'"); + } + arg5 = static_cast< float >(val5); + result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + aruco::Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + float arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + arg2 = reinterpret_cast< aruco::Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerPoseTracker_estimatePose__SWIG_1(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerPoseTracker_estimatePose__SWIG_0(self, args); + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerPoseTracker_estimatePose'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float,float)\n" + " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRTMatrix",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + result = ((aruco::MarkerPoseTracker const *)arg1)->getRTMatrix(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + result = ((aruco::MarkerPoseTracker const *)arg1)->getRvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getTvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + result = ((aruco::MarkerPoseTracker const *)arg1)->getTvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerPoseTracker")) SWIG_fail; + result = (aruco::MarkerPoseTracker *)new aruco::MarkerPoseTracker(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerPoseTracker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerPoseTracker" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerMapPoseTracker")) SWIG_fail; + result = (aruco::MarkerMapPoseTracker *)new aruco::MarkerMapPoseTracker(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::CameraParameters *arg2 = 0 ; + aruco::MarkerMap *arg3 = 0 ; + float arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::CameraParameters *arg2 = 0 ; + aruco::MarkerMap *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); + (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerMapPoseTracker_setParams__SWIG_1(self, args); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerMapPoseTracker_setParams__SWIG_0(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMapPoseTracker_setParams'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &,float)\n" + " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_isValid",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_isValid" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = (bool)((aruco::MarkerMapPoseTracker const *)arg1)->isValid(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_reset",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_reset" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + (arg1)->reset(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_estimatePose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMapPoseTracker_estimatePose",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + { + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res2 = swig::asptr(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg2 = ptr; + } + result = (bool)(arg1)->estimatePose((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRTMatrix",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRTMatrix(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getTvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = ((aruco::MarkerMapPoseTracker const *)arg1)->getTvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMapPoseTracker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMapPoseTracker" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerMapPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_DictionaryBased(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_DictionaryBased",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DictionaryBased" "', argument " "1"" of type '" "aruco::DictionaryBased *""'"); + } + arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DictionaryBased_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; + aruco::Dictionary *arg2 = 0 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:DictionaryBased_setParams",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_setParams" "', argument " "1"" of type '" "aruco::DictionaryBased *""'"); + } + arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Dictionary, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DictionaryBased_setParams" "', argument " "2"" of type '" "aruco::Dictionary const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_setParams" "', argument " "2"" of type '" "aruco::Dictionary const &""'"); + } + arg2 = reinterpret_cast< aruco::Dictionary * >(argp2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DictionaryBased_setParams" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setParams((aruco::Dictionary const &)*arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DictionaryBased_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; + cv::Mat *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + std::string *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:DictionaryBased_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_detect" "', argument " "1"" of type '" "aruco::DictionaryBased *""'"); + } + arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DictionaryBased_detect" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_detect" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DictionaryBased_detect" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_detect" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DictionaryBased_detect" "', argument " "5"" of type '" "std::string &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_detect" "', argument " "5"" of type '" "std::string &""'"); + } + arg5 = reinterpret_cast< std::string * >(argp5); + result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DictionaryBased_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:DictionaryBased_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_getName" "', argument " "1"" of type '" "aruco::DictionaryBased const *""'"); + } + arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); + result = ((aruco::DictionaryBased const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DictionaryBased_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:DictionaryBased_getNSubdivisions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_getNSubdivisions" "', argument " "1"" of type '" "aruco::DictionaryBased const *""'"); + } + arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); + result = (int)((aruco::DictionaryBased const *)arg1)->getNSubdivisions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DictionaryBased(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::DictionaryBased *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_DictionaryBased")) SWIG_fail; + result = (aruco::DictionaryBased *)new aruco::DictionaryBased(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__DictionaryBased, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *DictionaryBased_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__DictionaryBased, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_SVMMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::SVMMarkers *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_SVMMarkers")) SWIG_fail; + result = (aruco::SVMMarkers *)new aruco::SVMMarkers(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__SVMMarkers, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SVMMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_SVMMarkers",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SVMMarkers" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + } + arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SVMMarkers_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:SVMMarkers_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_getName" "', argument " "1"" of type '" "aruco::SVMMarkers const *""'"); + } + arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); + result = ((aruco::SVMMarkers const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SVMMarkers_load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SVMMarkers_load",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_load" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + } + arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SVMMarkers_load" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (bool)(arg1)->load(arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SVMMarkers_load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:SVMMarkers_load",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_load" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + } + arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); + result = (bool)(arg1)->load(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SVMMarkers_load(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__SVMMarkers, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SVMMarkers_load__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__SVMMarkers, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SVMMarkers_load__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SVMMarkers_load'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::SVMMarkers::load(std::string)\n" + " aruco::SVMMarkers::load()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SVMMarkers_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + cv::Mat *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + std::string *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:SVMMarkers_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_detect" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + } + arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SVMMarkers_detect" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVMMarkers_detect" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SVMMarkers_detect" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVMMarkers_detect" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SVMMarkers_detect" "', argument " "5"" of type '" "std::string &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVMMarkers_detect" "', argument " "5"" of type '" "std::string &""'"); + } + arg5 = reinterpret_cast< std::string * >(argp5); + result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SVMMarkers_getBestInputSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:SVMMarkers_getBestInputSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_getBestInputSize" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + } + arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); + result = (int)(arg1)->getBestInputSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SVMMarkers_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__SVMMarkers, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_ScopeTimer_begin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + std::chrono::high_resolution_clock::time_point arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_begin_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_begin_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopeTimer_begin_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopeTimer_begin_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); + } else { + std::chrono::high_resolution_clock::time_point * temp = reinterpret_cast< std::chrono::high_resolution_clock::time_point * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->begin = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_begin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::chrono::high_resolution_clock::time_point result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_begin_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_begin_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + result = ((arg1)->begin); + resultobj = SWIG_NewPointerObj((new std::chrono::high_resolution_clock::time_point(static_cast< const std::chrono::high_resolution_clock::time_point& >(result))), SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_end_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + std::chrono::high_resolution_clock::time_point arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_end_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_end_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopeTimer_end_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopeTimer_end_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); + } else { + std::chrono::high_resolution_clock::time_point * temp = reinterpret_cast< std::chrono::high_resolution_clock::time_point * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->end = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_end_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::chrono::high_resolution_clock::time_point result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_end_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_end_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + result = ((arg1)->end); + resultobj = SWIG_NewPointerObj((new std::chrono::high_resolution_clock::time_point(static_cast< const std::chrono::high_resolution_clock::time_point& >(result))), SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_name_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_name_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopeTimer_name_set" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopeTimer_name_set" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + if (arg1) (arg1)->name = *arg2; + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_name_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_name_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + result = (std::string *) & ((arg1)->name); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_use_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_use_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_use_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopeTimer_use_set" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + if (arg1) (arg1)->use = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_use_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_use_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_use_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + result = (bool) ((arg1)->use); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_sc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + aruco::ScopeTimer::SCALE arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_sc_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_sc_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopeTimer_sc_set" "', argument " "2"" of type '" "aruco::ScopeTimer::SCALE""'"); + } + arg2 = static_cast< aruco::ScopeTimer::SCALE >(val2); + if (arg1) (arg1)->sc = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopeTimer_sc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::ScopeTimer::SCALE result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_sc_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_sc_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + result = (aruco::ScopeTimer::SCALE) ((arg1)->sc); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopeTimer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + bool arg2 ; + aruco::ScopeTimer::SCALE arg3 ; + bool val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + aruco::ScopeTimer *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:new_ScopeTimer",&obj0,&obj1,&obj2)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopeTimer" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopeTimer" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScopeTimer" "', argument " "3"" of type '" "aruco::ScopeTimer::SCALE""'"); + } + arg3 = static_cast< aruco::ScopeTimer::SCALE >(val3); + result = (aruco::ScopeTimer *)new aruco::ScopeTimer(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopeTimer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + bool arg2 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::ScopeTimer *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_ScopeTimer",&obj0,&obj1)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopeTimer" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopeTimer" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (aruco::ScopeTimer *)new aruco::ScopeTimer(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopeTimer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::ScopeTimer *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopeTimer",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopeTimer" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (aruco::ScopeTimer *)new aruco::ScopeTimer(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopeTimer(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopeTimer__SWIG_2(self, args); + } + } + if (argc == 2) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ScopeTimer__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ScopeTimer__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopeTimer'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::ScopeTimer::ScopeTimer(std::string,bool,aruco::ScopeTimer::SCALE)\n" + " aruco::ScopeTimer::ScopeTimer(std::string,bool)\n" + " aruco::ScopeTimer::ScopeTimer(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_ScopeTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopeTimer",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopeTimer" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); + } + arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScopeTimer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__ScopeTimer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_sc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + aruco::ScopedTimerEvents::SCALE arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_sc_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_sc_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedTimerEvents_sc_set" "', argument " "2"" of type '" "aruco::ScopedTimerEvents::SCALE""'"); + } + arg2 = static_cast< aruco::ScopedTimerEvents::SCALE >(val2); + if (arg1) (arg1)->sc = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_sc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + aruco::ScopedTimerEvents::SCALE result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents_sc_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_sc_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + result = (aruco::ScopedTimerEvents::SCALE) ((arg1)->sc); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_vtimes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *arg2 = (std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_vtimes_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_vtimes_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents_vtimes_set" "', argument " "2"" of type '" "std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *""'"); + } + arg2 = reinterpret_cast< std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > * >(argp2); + if (arg1) (arg1)->vtimes = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_vtimes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents_vtimes_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_vtimes_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + result = (std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *)& ((arg1)->vtimes); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_names_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_names_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_names_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents_names_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); + } + arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2); + if (arg1) (arg1)->names = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_names_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< std::string,std::allocator< std::string > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents_names_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_names_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->names); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents__name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents__name_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents__name_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents__name_set" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedTimerEvents__name_set" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + if (arg1) (arg1)->_name = *arg2; + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents__name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents__name_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents__name_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + result = (std::string *) & ((arg1)->_name); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + bool arg2 ; + aruco::ScopedTimerEvents::SCALE arg3 ; + bool val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + aruco::ScopedTimerEvents *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:new_ScopedTimerEvents",&obj0,&obj1,&obj2)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopedTimerEvents" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopedTimerEvents" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScopedTimerEvents" "', argument " "3"" of type '" "aruco::ScopedTimerEvents::SCALE""'"); + } + arg3 = static_cast< aruco::ScopedTimerEvents::SCALE >(val3); + result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + bool arg2 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::ScopedTimerEvents *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_ScopedTimerEvents",&obj0,&obj1)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopedTimerEvents" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopedTimerEvents" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::ScopedTimerEvents *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedTimerEvents",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopedTimerEvents" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_ScopedTimerEvents")) SWIG_fail; + result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_ScopedTimerEvents__SWIG_3(self, args); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopedTimerEvents__SWIG_2(self, args); + } + } + if (argc == 2) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ScopedTimerEvents__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ScopedTimerEvents__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedTimerEvents'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::ScopedTimerEvents::ScopedTimerEvents(std::string,bool,aruco::ScopedTimerEvents::SCALE)\n" + " aruco::ScopedTimerEvents::ScopedTimerEvents(std::string,bool)\n" + " aruco::ScopedTimerEvents::ScopedTimerEvents(std::string)\n" + " aruco::ScopedTimerEvents::ScopedTimerEvents()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_add",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_add" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ScopedTimerEvents_add" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->add(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedTimerEvents_addspaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_addspaces",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_addspaces" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents_addspaces" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedTimerEvents_addspaces" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); + } + arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2); + (arg1)->addspaces(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ScopedTimerEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopedTimerEvents",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopedTimerEvents" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); + } + arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScopedTimerEvents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Timer__s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + std::chrono::high_resolution_clock::time_point arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Timer__s_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__s_set" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer__s_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Timer__s_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); + } else { + std::chrono::high_resolution_clock::time_point * temp = reinterpret_cast< std::chrono::high_resolution_clock::time_point * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->_s = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer__s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::chrono::high_resolution_clock::time_point result; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer__s_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__s_get" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + result = ((arg1)->_s); + resultobj = SWIG_NewPointerObj((new std::chrono::high_resolution_clock::time_point(static_cast< const std::chrono::high_resolution_clock::time_point& >(result))), SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_sum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Timer_sum_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_sum_set" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_sum_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->sum = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_sum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer_sum_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_sum_get" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + result = (double) ((arg1)->sum); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_n_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Timer_n_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_n_set" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_n_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->n = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer_n_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_n_get" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + result = (double) ((arg1)->n); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer__name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Timer__name_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__name_set" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer__name_set" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Timer__name_set" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + if (arg1) (arg1)->_name = *arg2; + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer__name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer__name_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__name_get" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + result = (std::string *) & ((arg1)->_name); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Timer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Timer")) SWIG_fail; + result = (aruco::Timer *)new aruco::Timer(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Timer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Timer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::Timer *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Timer",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Timer" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (aruco::Timer *)new aruco::Timer(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Timer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Timer(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_Timer__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Timer__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Timer'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Timer::Timer()\n" + " aruco::Timer::Timer(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Timer_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Timer_setName",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_setName" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Timer_setName" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setName(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer_start",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_start" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + (arg1)->start(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_end" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + (arg1)->end(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer__print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + aruco::Timer::SCALE arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Timer__print",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__print" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer__print" "', argument " "2"" of type '" "aruco::Timer::SCALE""'"); + } + arg2 = static_cast< aruco::Timer::SCALE >(val2); + (arg1)->print(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer__print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer__print",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__print" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + (arg1)->print(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer__print(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Timer__print__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Timer__print__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Timer__print'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Timer::print(aruco::Timer::SCALE)\n" + " aruco::Timer::print()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Timer_getAverage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + aruco::Timer::SCALE arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Timer_getAverage",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_getAverage" "', argument " "1"" of type '" "aruco::Timer const *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_getAverage" "', argument " "2"" of type '" "aruco::Timer::SCALE""'"); + } + arg2 = static_cast< aruco::Timer::SCALE >(val2); + result = (double)((aruco::Timer const *)arg1)->getAverage(arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_getAverage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"O:Timer_getAverage",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_getAverage" "', argument " "1"" of type '" "aruco::Timer const *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + result = (double)((aruco::Timer const *)arg1)->getAverage(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Timer_getAverage(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Timer_getAverage__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Timer_getAverage__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Timer_getAverage'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Timer::getAverage(aruco::Timer::SCALE) const\n" + " aruco::Timer::getAverage() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Timer *arg1 = (aruco::Timer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Timer",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', argument " "1"" of type '" "aruco::Timer *""'"); + } + arg1 = reinterpret_cast< aruco::Timer * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Timer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +static PyMethodDef SwigMethods[] = { + { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, + { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL}, + { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL}, + { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL}, + { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL}, + { (char *)"VectorInt___bool__", _wrap_VectorInt___bool__, METH_VARARGS, NULL}, + { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL}, + { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL}, + { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL}, + { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL}, + { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL}, + { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL}, + { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL}, + { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL}, + { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL}, + { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL}, + { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL}, + { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL}, + { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL}, + { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL}, + { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL}, + { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL}, + { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL}, + { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL}, + { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL}, + { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL}, + { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL}, + { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL}, + { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL}, + { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL}, + { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL}, + { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL}, + { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL}, + { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL}, + { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL}, + { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL}, + { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL}, + { (char *)"ARUCO_VERSION_MAJOR_swigconstant", ARUCO_VERSION_MAJOR_swigconstant, METH_VARARGS, NULL}, + { (char *)"ARUCO_VERSION_MINOR_swigconstant", ARUCO_VERSION_MINOR_swigconstant, METH_VARARGS, NULL}, + { (char *)"CameraParameters_CameraMatrix_set", _wrap_CameraParameters_CameraMatrix_set, METH_VARARGS, NULL}, + { (char *)"CameraParameters_CameraMatrix_get", _wrap_CameraParameters_CameraMatrix_get, METH_VARARGS, NULL}, + { (char *)"CameraParameters_Distorsion_set", _wrap_CameraParameters_Distorsion_set, METH_VARARGS, NULL}, + { (char *)"CameraParameters_Distorsion_get", _wrap_CameraParameters_Distorsion_get, METH_VARARGS, NULL}, + { (char *)"CameraParameters_CamSize_set", _wrap_CameraParameters_CamSize_set, METH_VARARGS, NULL}, + { (char *)"CameraParameters_CamSize_get", _wrap_CameraParameters_CamSize_get, METH_VARARGS, NULL}, + { (char *)"CameraParameters_setParams", _wrap_CameraParameters_setParams, METH_VARARGS, NULL}, + { (char *)"new_CameraParameters", _wrap_new_CameraParameters, METH_VARARGS, NULL}, + { (char *)"CameraParameters_isValid", _wrap_CameraParameters_isValid, METH_VARARGS, NULL}, + { (char *)"CameraParameters_saveToFile", _wrap_CameraParameters_saveToFile, METH_VARARGS, NULL}, + { (char *)"CameraParameters_readFromXMLFile", _wrap_CameraParameters_readFromXMLFile, METH_VARARGS, NULL}, + { (char *)"CameraParameters_resize", _wrap_CameraParameters_resize, METH_VARARGS, NULL}, + { (char *)"CameraParameters_getCameraLocation", _wrap_CameraParameters_getCameraLocation, METH_VARARGS, NULL}, + { (char *)"CameraParameters_glGetProjectionMatrix", _wrap_CameraParameters_glGetProjectionMatrix, METH_VARARGS, NULL}, + { (char *)"CameraParameters_OgreGetProjectionMatrix", _wrap_CameraParameters_OgreGetProjectionMatrix, METH_VARARGS, NULL}, + { (char *)"CameraParameters_getRTMatrix", _wrap_CameraParameters_getRTMatrix, METH_VARARGS, NULL}, + { (char *)"delete_CameraParameters", _wrap_delete_CameraParameters, METH_VARARGS, NULL}, + { (char *)"CameraParameters_swigregister", CameraParameters_swigregister, METH_VARARGS, NULL}, + { (char *)"CvDrawingUtils_draw3dAxis", _wrap_CvDrawingUtils_draw3dAxis, METH_VARARGS, NULL}, + { (char *)"CvDrawingUtils_draw3dCube", _wrap_CvDrawingUtils_draw3dCube, METH_VARARGS, NULL}, + { (char *)"new_CvDrawingUtils", _wrap_new_CvDrawingUtils, METH_VARARGS, NULL}, + { (char *)"delete_CvDrawingUtils", _wrap_delete_CvDrawingUtils, METH_VARARGS, NULL}, + { (char *)"CvDrawingUtils_swigregister", CvDrawingUtils_swigregister, METH_VARARGS, NULL}, + { (char *)"Debug_init", _wrap_Debug_init, METH_VARARGS, NULL}, + { (char *)"Debug_setLevel", _wrap_Debug_setLevel, METH_VARARGS, NULL}, + { (char *)"Debug_getLevel", _wrap_Debug_getLevel, METH_VARARGS, NULL}, + { (char *)"Debug_addString", _wrap_Debug_addString, METH_VARARGS, NULL}, + { (char *)"Debug_getString", _wrap_Debug_getString, METH_VARARGS, NULL}, + { (char *)"Debug_getFileName", _wrap_Debug_getFileName, METH_VARARGS, NULL}, + { (char *)"new_Debug", _wrap_new_Debug, METH_VARARGS, NULL}, + { (char *)"delete_Debug", _wrap_delete_Debug, METH_VARARGS, NULL}, + { (char *)"Debug_swigregister", Debug_swigregister, METH_VARARGS, NULL}, + { (char *)"Dictionary__is", _wrap_Dictionary__is, METH_VARARGS, NULL}, + { (char *)"Dictionary_getType", _wrap_Dictionary_getType, METH_VARARGS, NULL}, + { (char *)"Dictionary_size", _wrap_Dictionary_size, METH_VARARGS, NULL}, + { (char *)"Dictionary_nbits", _wrap_Dictionary_nbits, METH_VARARGS, NULL}, + { (char *)"Dictionary_tau", _wrap_Dictionary_tau, METH_VARARGS, NULL}, + { (char *)"Dictionary_getName", _wrap_Dictionary_getName, METH_VARARGS, NULL}, + { (char *)"Dictionary_getMapCode", _wrap_Dictionary_getMapCode, METH_VARARGS, NULL}, + { (char *)"Dictionary_at", _wrap_Dictionary_at, METH_VARARGS, NULL}, + { (char *)"Dictionary_getMarkerImage_id", _wrap_Dictionary_getMarkerImage_id, METH_VARARGS, NULL}, + { (char *)"Dictionary_createMarkerMap", _wrap_Dictionary_createMarkerMap, METH_VARARGS, NULL}, + { (char *)"Dictionary_loadPredefined", _wrap_Dictionary_loadPredefined, METH_VARARGS, NULL}, + { (char *)"Dictionary_loadFromFile", _wrap_Dictionary_loadFromFile, METH_VARARGS, NULL}, + { (char *)"Dictionary_load", _wrap_Dictionary_load, METH_VARARGS, NULL}, + { (char *)"Dictionary_computeDictionaryDistance", _wrap_Dictionary_computeDictionaryDistance, METH_VARARGS, NULL}, + { (char *)"Dictionary_getTypeFromString", _wrap_Dictionary_getTypeFromString, METH_VARARGS, NULL}, + { (char *)"Dictionary_getTypeString", _wrap_Dictionary_getTypeString, METH_VARARGS, NULL}, + { (char *)"Dictionary_isPredefinedDictinaryString", _wrap_Dictionary_isPredefinedDictinaryString, METH_VARARGS, NULL}, + { (char *)"Dictionary_getDicTypes", _wrap_Dictionary_getDicTypes, METH_VARARGS, NULL}, + { (char *)"new_Dictionary", _wrap_new_Dictionary, METH_VARARGS, NULL}, + { (char *)"delete_Dictionary", _wrap_delete_Dictionary, METH_VARARGS, NULL}, + { (char *)"Dictionary_swigregister", Dictionary_swigregister, METH_VARARGS, NULL}, + { (char *)"Point2fVec_iterator", _wrap_Point2fVec_iterator, METH_VARARGS, NULL}, + { (char *)"Point2fVec___nonzero__", _wrap_Point2fVec___nonzero__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___bool__", _wrap_Point2fVec___bool__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___len__", _wrap_Point2fVec___len__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___getslice__", _wrap_Point2fVec___getslice__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___setslice__", _wrap_Point2fVec___setslice__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___delslice__", _wrap_Point2fVec___delslice__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___delitem__", _wrap_Point2fVec___delitem__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___getitem__", _wrap_Point2fVec___getitem__, METH_VARARGS, NULL}, + { (char *)"Point2fVec___setitem__", _wrap_Point2fVec___setitem__, METH_VARARGS, NULL}, + { (char *)"Point2fVec_pop", _wrap_Point2fVec_pop, METH_VARARGS, NULL}, + { (char *)"Point2fVec_append", _wrap_Point2fVec_append, METH_VARARGS, NULL}, + { (char *)"Point2fVec_empty", _wrap_Point2fVec_empty, METH_VARARGS, NULL}, + { (char *)"Point2fVec_size", _wrap_Point2fVec_size, METH_VARARGS, NULL}, + { (char *)"Point2fVec_swap", _wrap_Point2fVec_swap, METH_VARARGS, NULL}, + { (char *)"Point2fVec_begin", _wrap_Point2fVec_begin, METH_VARARGS, NULL}, + { (char *)"Point2fVec_end", _wrap_Point2fVec_end, METH_VARARGS, NULL}, + { (char *)"Point2fVec_rbegin", _wrap_Point2fVec_rbegin, METH_VARARGS, NULL}, + { (char *)"Point2fVec_rend", _wrap_Point2fVec_rend, METH_VARARGS, NULL}, + { (char *)"Point2fVec_clear", _wrap_Point2fVec_clear, METH_VARARGS, NULL}, + { (char *)"Point2fVec_get_allocator", _wrap_Point2fVec_get_allocator, METH_VARARGS, NULL}, + { (char *)"Point2fVec_pop_back", _wrap_Point2fVec_pop_back, METH_VARARGS, NULL}, + { (char *)"Point2fVec_erase", _wrap_Point2fVec_erase, METH_VARARGS, NULL}, + { (char *)"new_Point2fVec", _wrap_new_Point2fVec, METH_VARARGS, NULL}, + { (char *)"Point2fVec_push_back", _wrap_Point2fVec_push_back, METH_VARARGS, NULL}, + { (char *)"Point2fVec_front", _wrap_Point2fVec_front, METH_VARARGS, NULL}, + { (char *)"Point2fVec_back", _wrap_Point2fVec_back, METH_VARARGS, NULL}, + { (char *)"Point2fVec_assign", _wrap_Point2fVec_assign, METH_VARARGS, NULL}, + { (char *)"Point2fVec_resize", _wrap_Point2fVec_resize, METH_VARARGS, NULL}, + { (char *)"Point2fVec_insert", _wrap_Point2fVec_insert, METH_VARARGS, NULL}, + { (char *)"Point2fVec_reserve", _wrap_Point2fVec_reserve, METH_VARARGS, NULL}, + { (char *)"Point2fVec_capacity", _wrap_Point2fVec_capacity, METH_VARARGS, NULL}, + { (char *)"delete_Point2fVec", _wrap_delete_Point2fVec, METH_VARARGS, NULL}, + { (char *)"Point2fVec_swigregister", Point2fVec_swigregister, METH_VARARGS, NULL}, + { (char *)"MarkerVec_iterator", _wrap_MarkerVec_iterator, METH_VARARGS, NULL}, + { (char *)"MarkerVec___nonzero__", _wrap_MarkerVec___nonzero__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___bool__", _wrap_MarkerVec___bool__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___len__", _wrap_MarkerVec___len__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___getslice__", _wrap_MarkerVec___getslice__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___setslice__", _wrap_MarkerVec___setslice__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___delslice__", _wrap_MarkerVec___delslice__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___delitem__", _wrap_MarkerVec___delitem__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___getitem__", _wrap_MarkerVec___getitem__, METH_VARARGS, NULL}, + { (char *)"MarkerVec___setitem__", _wrap_MarkerVec___setitem__, METH_VARARGS, NULL}, + { (char *)"MarkerVec_pop", _wrap_MarkerVec_pop, METH_VARARGS, NULL}, + { (char *)"MarkerVec_append", _wrap_MarkerVec_append, METH_VARARGS, NULL}, + { (char *)"MarkerVec_empty", _wrap_MarkerVec_empty, METH_VARARGS, NULL}, + { (char *)"MarkerVec_size", _wrap_MarkerVec_size, METH_VARARGS, NULL}, + { (char *)"MarkerVec_swap", _wrap_MarkerVec_swap, METH_VARARGS, NULL}, + { (char *)"MarkerVec_begin", _wrap_MarkerVec_begin, METH_VARARGS, NULL}, + { (char *)"MarkerVec_end", _wrap_MarkerVec_end, METH_VARARGS, NULL}, + { (char *)"MarkerVec_rbegin", _wrap_MarkerVec_rbegin, METH_VARARGS, NULL}, + { (char *)"MarkerVec_rend", _wrap_MarkerVec_rend, METH_VARARGS, NULL}, + { (char *)"MarkerVec_clear", _wrap_MarkerVec_clear, METH_VARARGS, NULL}, + { (char *)"MarkerVec_get_allocator", _wrap_MarkerVec_get_allocator, METH_VARARGS, NULL}, + { (char *)"MarkerVec_pop_back", _wrap_MarkerVec_pop_back, METH_VARARGS, NULL}, + { (char *)"MarkerVec_erase", _wrap_MarkerVec_erase, METH_VARARGS, NULL}, + { (char *)"new_MarkerVec", _wrap_new_MarkerVec, METH_VARARGS, NULL}, + { (char *)"MarkerVec_push_back", _wrap_MarkerVec_push_back, METH_VARARGS, NULL}, + { (char *)"MarkerVec_front", _wrap_MarkerVec_front, METH_VARARGS, NULL}, + { (char *)"MarkerVec_back", _wrap_MarkerVec_back, METH_VARARGS, NULL}, + { (char *)"MarkerVec_assign", _wrap_MarkerVec_assign, METH_VARARGS, NULL}, + { (char *)"MarkerVec_resize", _wrap_MarkerVec_resize, METH_VARARGS, NULL}, + { (char *)"MarkerVec_insert", _wrap_MarkerVec_insert, METH_VARARGS, NULL}, + { (char *)"MarkerVec_reserve", _wrap_MarkerVec_reserve, METH_VARARGS, NULL}, + { (char *)"MarkerVec_capacity", _wrap_MarkerVec_capacity, METH_VARARGS, NULL}, + { (char *)"delete_MarkerVec", _wrap_delete_MarkerVec, METH_VARARGS, NULL}, + { (char *)"MarkerVec_swigregister", MarkerVec_swigregister, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_iterator", _wrap_VectorMarker3DInfo_iterator, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___nonzero__", _wrap_VectorMarker3DInfo___nonzero__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___bool__", _wrap_VectorMarker3DInfo___bool__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___len__", _wrap_VectorMarker3DInfo___len__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___getslice__", _wrap_VectorMarker3DInfo___getslice__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___setslice__", _wrap_VectorMarker3DInfo___setslice__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___delslice__", _wrap_VectorMarker3DInfo___delslice__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___delitem__", _wrap_VectorMarker3DInfo___delitem__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___getitem__", _wrap_VectorMarker3DInfo___getitem__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo___setitem__", _wrap_VectorMarker3DInfo___setitem__, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_pop", _wrap_VectorMarker3DInfo_pop, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_append", _wrap_VectorMarker3DInfo_append, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_empty", _wrap_VectorMarker3DInfo_empty, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_size", _wrap_VectorMarker3DInfo_size, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_swap", _wrap_VectorMarker3DInfo_swap, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_begin", _wrap_VectorMarker3DInfo_begin, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_end", _wrap_VectorMarker3DInfo_end, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_rbegin", _wrap_VectorMarker3DInfo_rbegin, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_rend", _wrap_VectorMarker3DInfo_rend, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_clear", _wrap_VectorMarker3DInfo_clear, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_get_allocator", _wrap_VectorMarker3DInfo_get_allocator, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_pop_back", _wrap_VectorMarker3DInfo_pop_back, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_erase", _wrap_VectorMarker3DInfo_erase, METH_VARARGS, NULL}, + { (char *)"new_VectorMarker3DInfo", _wrap_new_VectorMarker3DInfo, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_push_back", _wrap_VectorMarker3DInfo_push_back, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_front", _wrap_VectorMarker3DInfo_front, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_back", _wrap_VectorMarker3DInfo_back, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_assign", _wrap_VectorMarker3DInfo_assign, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_resize", _wrap_VectorMarker3DInfo_resize, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_insert", _wrap_VectorMarker3DInfo_insert, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_reserve", _wrap_VectorMarker3DInfo_reserve, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_capacity", _wrap_VectorMarker3DInfo_capacity, METH_VARARGS, NULL}, + { (char *)"delete_VectorMarker3DInfo", _wrap_delete_VectorMarker3DInfo, METH_VARARGS, NULL}, + { (char *)"VectorMarker3DInfo_swigregister", VectorMarker3DInfo_swigregister, METH_VARARGS, NULL}, + { (char *)"Marker_id_set", _wrap_Marker_id_set, METH_VARARGS, NULL}, + { (char *)"Marker_id_get", _wrap_Marker_id_get, METH_VARARGS, NULL}, + { (char *)"Marker_ssize_set", _wrap_Marker_ssize_set, METH_VARARGS, NULL}, + { (char *)"Marker_ssize_get", _wrap_Marker_ssize_get, METH_VARARGS, NULL}, + { (char *)"Marker_Rvec_set", _wrap_Marker_Rvec_set, METH_VARARGS, NULL}, + { (char *)"Marker_Rvec_get", _wrap_Marker_Rvec_get, METH_VARARGS, NULL}, + { (char *)"Marker_Tvec_set", _wrap_Marker_Tvec_set, METH_VARARGS, NULL}, + { (char *)"Marker_Tvec_get", _wrap_Marker_Tvec_get, METH_VARARGS, NULL}, + { (char *)"Marker_dict_info_set", _wrap_Marker_dict_info_set, METH_VARARGS, NULL}, + { (char *)"Marker_dict_info_get", _wrap_Marker_dict_info_get, METH_VARARGS, NULL}, + { (char *)"new_Marker", _wrap_new_Marker, METH_VARARGS, NULL}, + { (char *)"delete_Marker", _wrap_delete_Marker, METH_VARARGS, NULL}, + { (char *)"Marker_isValid", _wrap_Marker_isValid, METH_VARARGS, NULL}, + { (char *)"Marker_isPoseValid", _wrap_Marker_isPoseValid, METH_VARARGS, NULL}, + { (char *)"Marker_draw", _wrap_Marker_draw, METH_VARARGS, NULL}, + { (char *)"Marker_calculateExtrinsics", _wrap_Marker_calculateExtrinsics, METH_VARARGS, NULL}, + { (char *)"Marker_glGetModelViewMatrix", _wrap_Marker_glGetModelViewMatrix, METH_VARARGS, NULL}, + { (char *)"Marker_OgreGetPoseParameters", _wrap_Marker_OgreGetPoseParameters, METH_VARARGS, NULL}, + { (char *)"Marker_getCenter", _wrap_Marker_getCenter, METH_VARARGS, NULL}, + { (char *)"Marker_getPerimeter", _wrap_Marker_getPerimeter, METH_VARARGS, NULL}, + { (char *)"Marker_getArea", _wrap_Marker_getArea, METH_VARARGS, NULL}, + { (char *)"Marker___eq__", _wrap_Marker___eq__, METH_VARARGS, NULL}, + { (char *)"Marker_copyTo", _wrap_Marker_copyTo, METH_VARARGS, NULL}, + { (char *)"Marker_toStream", _wrap_Marker_toStream, METH_VARARGS, NULL}, + { (char *)"Marker_fromStream", _wrap_Marker_fromStream, METH_VARARGS, NULL}, + { (char *)"Marker_get3DPoints", _wrap_Marker_get3DPoints, METH_VARARGS, NULL}, + { (char *)"Marker___getitem__", _wrap_Marker___getitem__, METH_VARARGS, NULL}, + { (char *)"Marker_swigregister", Marker_swigregister, METH_VARARGS, NULL}, + { (char *)"DM_NORMAL_swigconstant", DM_NORMAL_swigconstant, METH_VARARGS, NULL}, + { (char *)"DM_FAST_swigconstant", DM_FAST_swigconstant, METH_VARARGS, NULL}, + { (char *)"DM_VIDEO_FAST_swigconstant", DM_VIDEO_FAST_swigconstant, METH_VARARGS, NULL}, + { (char *)"THRES_ADAPTIVE_swigconstant", THRES_ADAPTIVE_swigconstant, METH_VARARGS, NULL}, + { (char *)"THRES_AUTO_FIXED_swigconstant", THRES_AUTO_FIXED_swigconstant, METH_VARARGS, NULL}, + { (char *)"Params_maxThreads_set", _wrap_Params_maxThreads_set, METH_VARARGS, NULL}, + { (char *)"Params_maxThreads_get", _wrap_Params_maxThreads_get, METH_VARARGS, NULL}, + { (char *)"Params_borderDistThres_set", _wrap_Params_borderDistThres_set, METH_VARARGS, NULL}, + { (char *)"Params_borderDistThres_get", _wrap_Params_borderDistThres_get, METH_VARARGS, NULL}, + { (char *)"Params_lowResMarkerSize_set", _wrap_Params_lowResMarkerSize_set, METH_VARARGS, NULL}, + { (char *)"Params_lowResMarkerSize_get", _wrap_Params_lowResMarkerSize_get, METH_VARARGS, NULL}, + { (char *)"Params_minSize_set", _wrap_Params_minSize_set, METH_VARARGS, NULL}, + { (char *)"Params_minSize_get", _wrap_Params_minSize_get, METH_VARARGS, NULL}, + { (char *)"Params_minSize_pix_set", _wrap_Params_minSize_pix_set, METH_VARARGS, NULL}, + { (char *)"Params_minSize_pix_get", _wrap_Params_minSize_pix_get, METH_VARARGS, NULL}, + { (char *)"Params_enclosedMarker_set", _wrap_Params_enclosedMarker_set, METH_VARARGS, NULL}, + { (char *)"Params_enclosedMarker_get", _wrap_Params_enclosedMarker_get, METH_VARARGS, NULL}, + { (char *)"Params_setThresholdMethod", _wrap_Params_setThresholdMethod, METH_VARARGS, NULL}, + { (char *)"Params__thresMethod_set", _wrap_Params__thresMethod_set, METH_VARARGS, NULL}, + { (char *)"Params__thresMethod_get", _wrap_Params__thresMethod_get, METH_VARARGS, NULL}, + { (char *)"Params_NAttemptsAutoThresFix_set", _wrap_Params_NAttemptsAutoThresFix_set, METH_VARARGS, NULL}, + { (char *)"Params_NAttemptsAutoThresFix_get", _wrap_Params_NAttemptsAutoThresFix_get, METH_VARARGS, NULL}, + { (char *)"Params__AdaptiveThresWindowSize_set", _wrap_Params__AdaptiveThresWindowSize_set, METH_VARARGS, NULL}, + { (char *)"Params__AdaptiveThresWindowSize_get", _wrap_Params__AdaptiveThresWindowSize_get, METH_VARARGS, NULL}, + { (char *)"Params__ThresHold_set", _wrap_Params__ThresHold_set, METH_VARARGS, NULL}, + { (char *)"Params__ThresHold_get", _wrap_Params__ThresHold_get, METH_VARARGS, NULL}, + { (char *)"Params__AdaptiveThresWindowSize_range_set", _wrap_Params__AdaptiveThresWindowSize_range_set, METH_VARARGS, NULL}, + { (char *)"Params__AdaptiveThresWindowSize_range_get", _wrap_Params__AdaptiveThresWindowSize_range_get, METH_VARARGS, NULL}, + { (char *)"Params__markerWarpPixSize_set", _wrap_Params__markerWarpPixSize_set, METH_VARARGS, NULL}, + { (char *)"Params__markerWarpPixSize_get", _wrap_Params__markerWarpPixSize_get, METH_VARARGS, NULL}, + { (char *)"Params__autoSize_set", _wrap_Params__autoSize_set, METH_VARARGS, NULL}, + { (char *)"Params__autoSize_get", _wrap_Params__autoSize_get, METH_VARARGS, NULL}, + { (char *)"Params__ts_set", _wrap_Params__ts_set, METH_VARARGS, NULL}, + { (char *)"Params__ts_get", _wrap_Params__ts_get, METH_VARARGS, NULL}, + { (char *)"Params_setAutoSizeSpeedUp", _wrap_Params_setAutoSizeSpeedUp, METH_VARARGS, NULL}, + { (char *)"Params_getAutoSizeSpeedUp", _wrap_Params_getAutoSizeSpeedUp, METH_VARARGS, NULL}, + { (char *)"Params_pyrfactor_set", _wrap_Params_pyrfactor_set, METH_VARARGS, NULL}, + { (char *)"Params_pyrfactor_get", _wrap_Params_pyrfactor_get, METH_VARARGS, NULL}, + { (char *)"new_Params", _wrap_new_Params, METH_VARARGS, NULL}, + { (char *)"delete_Params", _wrap_delete_Params, METH_VARARGS, NULL}, + { (char *)"Params_swigregister", Params_swigregister, METH_VARARGS, NULL}, + { (char *)"new_MarkerCandidate", _wrap_new_MarkerCandidate, METH_VARARGS, NULL}, + { (char *)"MarkerCandidate_contour_set", _wrap_MarkerCandidate_contour_set, METH_VARARGS, NULL}, + { (char *)"MarkerCandidate_contour_get", _wrap_MarkerCandidate_contour_get, METH_VARARGS, NULL}, + { (char *)"MarkerCandidate_idx_set", _wrap_MarkerCandidate_idx_set, METH_VARARGS, NULL}, + { (char *)"MarkerCandidate_idx_get", _wrap_MarkerCandidate_idx_get, METH_VARARGS, NULL}, + { (char *)"delete_MarkerCandidate", _wrap_delete_MarkerCandidate, METH_VARARGS, NULL}, + { (char *)"MarkerCandidate_swigregister", MarkerCandidate_swigregister, METH_VARARGS, NULL}, + { (char *)"new_MarkerDetector", _wrap_new_MarkerDetector, METH_VARARGS, NULL}, + { (char *)"delete_MarkerDetector", _wrap_delete_MarkerDetector, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_setDetectionMode", _wrap_MarkerDetector_setDetectionMode, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_getDetectionMode", _wrap_MarkerDetector_getDetectionMode, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_detect", _wrap_MarkerDetector_detect, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_getParameters", _wrap_MarkerDetector_getParameters, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_setDictionary", _wrap_MarkerDetector_setDictionary, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_getThresholdedImage", _wrap_MarkerDetector_getThresholdedImage, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_setMarkerLabeler", _wrap_MarkerDetector_setMarkerLabeler, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_getMarkerLabeler", _wrap_MarkerDetector_getMarkerLabeler, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_getCandidates", _wrap_MarkerDetector_getCandidates, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_warp", _wrap_MarkerDetector_warp, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_swigregister", MarkerDetector_swigregister, METH_VARARGS, NULL}, + { (char *)"MarkerLabeler_create", _wrap_MarkerLabeler_create, METH_VARARGS, NULL}, + { (char *)"MarkerLabeler_detect", _wrap_MarkerLabeler_detect, METH_VARARGS, NULL}, + { (char *)"MarkerLabeler_getBestInputSize", _wrap_MarkerLabeler_getBestInputSize, METH_VARARGS, NULL}, + { (char *)"MarkerLabeler_getNSubdivisions", _wrap_MarkerLabeler_getNSubdivisions, METH_VARARGS, NULL}, + { (char *)"MarkerLabeler_getName", _wrap_MarkerLabeler_getName, METH_VARARGS, NULL}, + { (char *)"delete_MarkerLabeler", _wrap_delete_MarkerLabeler, METH_VARARGS, NULL}, + { (char *)"MarkerLabeler_swigregister", MarkerLabeler_swigregister, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_points_set", _wrap_Marker3DInfo_points_set, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_points_get", _wrap_Marker3DInfo_points_get, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_id_set", _wrap_Marker3DInfo_id_set, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_id_get", _wrap_Marker3DInfo_id_get, METH_VARARGS, NULL}, + { (char *)"new_Marker3DInfo", _wrap_new_Marker3DInfo, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo___eq__", _wrap_Marker3DInfo___eq__, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_getMarkerSize", _wrap_Marker3DInfo_getMarkerSize, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_at", _wrap_Marker3DInfo_at, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_push_back", _wrap_Marker3DInfo_push_back, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_size", _wrap_Marker3DInfo_size, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_toStream", _wrap_Marker3DInfo_toStream, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_fromStream", _wrap_Marker3DInfo_fromStream, METH_VARARGS, NULL}, + { (char *)"delete_Marker3DInfo", _wrap_delete_Marker3DInfo, METH_VARARGS, NULL}, + { (char *)"Marker3DInfo_swigregister", Marker3DInfo_swigregister, METH_VARARGS, NULL}, + { (char *)"new_MarkerMap", _wrap_new_MarkerMap, METH_VARARGS, NULL}, + { (char *)"MarkerMap_isExpressedInMeters", _wrap_MarkerMap_isExpressedInMeters, METH_VARARGS, NULL}, + { (char *)"MarkerMap_isExpressedInPixels", _wrap_MarkerMap_isExpressedInPixels, METH_VARARGS, NULL}, + { (char *)"MarkerMap_convertToMeters", _wrap_MarkerMap_convertToMeters, METH_VARARGS, NULL}, + { (char *)"MarkerMap_getIndices", _wrap_MarkerMap_getIndices, METH_VARARGS, NULL}, + { (char *)"MarkerMap_getMarker3DInfo", _wrap_MarkerMap_getMarker3DInfo, METH_VARARGS, NULL}, + { (char *)"MarkerMap_getIndexOfMarkerId", _wrap_MarkerMap_getIndexOfMarkerId, METH_VARARGS, NULL}, + { (char *)"MarkerMap_getIdList", _wrap_MarkerMap_getIdList, METH_VARARGS, NULL}, + { (char *)"MarkerMap_getImage", _wrap_MarkerMap_getImage, METH_VARARGS, NULL}, + { (char *)"MarkerMap_saveToFile", _wrap_MarkerMap_saveToFile, METH_VARARGS, NULL}, + { (char *)"MarkerMap_readFromFile", _wrap_MarkerMap_readFromFile, METH_VARARGS, NULL}, + { (char *)"MarkerMap_calculateExtrinsics", _wrap_MarkerMap_calculateExtrinsics, METH_VARARGS, NULL}, + { (char *)"MarkerMap_getDictionary", _wrap_MarkerMap_getDictionary, METH_VARARGS, NULL}, + { (char *)"MarkerMap_setDictionary", _wrap_MarkerMap_setDictionary, METH_VARARGS, NULL}, + { (char *)"MarkerMap_mInfoType_set", _wrap_MarkerMap_mInfoType_set, METH_VARARGS, NULL}, + { (char *)"MarkerMap_mInfoType_get", _wrap_MarkerMap_mInfoType_get, METH_VARARGS, NULL}, + { (char *)"MarkerMap_toStream", _wrap_MarkerMap_toStream, METH_VARARGS, NULL}, + { (char *)"MarkerMap_fromStream", _wrap_MarkerMap_fromStream, METH_VARARGS, NULL}, + { (char *)"delete_MarkerMap", _wrap_delete_MarkerMap, METH_VARARGS, NULL}, + { (char *)"MarkerMap_swigregister", MarkerMap_swigregister, METH_VARARGS, NULL}, + { (char *)"MarkerPoseTracker_estimatePose", _wrap_MarkerPoseTracker_estimatePose, METH_VARARGS, NULL}, + { (char *)"MarkerPoseTracker_getRTMatrix", _wrap_MarkerPoseTracker_getRTMatrix, METH_VARARGS, NULL}, + { (char *)"MarkerPoseTracker_getRvec", _wrap_MarkerPoseTracker_getRvec, METH_VARARGS, NULL}, + { (char *)"MarkerPoseTracker_getTvec", _wrap_MarkerPoseTracker_getTvec, METH_VARARGS, NULL}, + { (char *)"new_MarkerPoseTracker", _wrap_new_MarkerPoseTracker, METH_VARARGS, NULL}, + { (char *)"delete_MarkerPoseTracker", _wrap_delete_MarkerPoseTracker, METH_VARARGS, NULL}, + { (char *)"MarkerPoseTracker_swigregister", MarkerPoseTracker_swigregister, METH_VARARGS, NULL}, + { (char *)"new_MarkerMapPoseTracker", _wrap_new_MarkerMapPoseTracker, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_setParams", _wrap_MarkerMapPoseTracker_setParams, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_isValid", _wrap_MarkerMapPoseTracker_isValid, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_reset", _wrap_MarkerMapPoseTracker_reset, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_estimatePose", _wrap_MarkerMapPoseTracker_estimatePose, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_getRTMatrix", _wrap_MarkerMapPoseTracker_getRTMatrix, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_getRvec", _wrap_MarkerMapPoseTracker_getRvec, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_getTvec", _wrap_MarkerMapPoseTracker_getTvec, METH_VARARGS, NULL}, + { (char *)"delete_MarkerMapPoseTracker", _wrap_delete_MarkerMapPoseTracker, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_swigregister", MarkerMapPoseTracker_swigregister, METH_VARARGS, NULL}, + { (char *)"delete_DictionaryBased", _wrap_delete_DictionaryBased, METH_VARARGS, NULL}, + { (char *)"DictionaryBased_setParams", _wrap_DictionaryBased_setParams, METH_VARARGS, NULL}, + { (char *)"DictionaryBased_detect", _wrap_DictionaryBased_detect, METH_VARARGS, NULL}, + { (char *)"DictionaryBased_getName", _wrap_DictionaryBased_getName, METH_VARARGS, NULL}, + { (char *)"DictionaryBased_getNSubdivisions", _wrap_DictionaryBased_getNSubdivisions, METH_VARARGS, NULL}, + { (char *)"new_DictionaryBased", _wrap_new_DictionaryBased, METH_VARARGS, NULL}, + { (char *)"DictionaryBased_swigregister", DictionaryBased_swigregister, METH_VARARGS, NULL}, + { (char *)"new_SVMMarkers", _wrap_new_SVMMarkers, METH_VARARGS, NULL}, + { (char *)"delete_SVMMarkers", _wrap_delete_SVMMarkers, METH_VARARGS, NULL}, + { (char *)"SVMMarkers_getName", _wrap_SVMMarkers_getName, METH_VARARGS, NULL}, + { (char *)"SVMMarkers_load", _wrap_SVMMarkers_load, METH_VARARGS, NULL}, + { (char *)"SVMMarkers_detect", _wrap_SVMMarkers_detect, METH_VARARGS, NULL}, + { (char *)"SVMMarkers_getBestInputSize", _wrap_SVMMarkers_getBestInputSize, METH_VARARGS, NULL}, + { (char *)"SVMMarkers_swigregister", SVMMarkers_swigregister, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_begin_set", _wrap_ScopeTimer_begin_set, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_begin_get", _wrap_ScopeTimer_begin_get, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_end_set", _wrap_ScopeTimer_end_set, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_end_get", _wrap_ScopeTimer_end_get, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_name_set", _wrap_ScopeTimer_name_set, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_name_get", _wrap_ScopeTimer_name_get, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_use_set", _wrap_ScopeTimer_use_set, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_use_get", _wrap_ScopeTimer_use_get, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_sc_set", _wrap_ScopeTimer_sc_set, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_sc_get", _wrap_ScopeTimer_sc_get, METH_VARARGS, NULL}, + { (char *)"new_ScopeTimer", _wrap_new_ScopeTimer, METH_VARARGS, NULL}, + { (char *)"delete_ScopeTimer", _wrap_delete_ScopeTimer, METH_VARARGS, NULL}, + { (char *)"ScopeTimer_swigregister", ScopeTimer_swigregister, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_sc_set", _wrap_ScopedTimerEvents_sc_set, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_sc_get", _wrap_ScopedTimerEvents_sc_get, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_vtimes_set", _wrap_ScopedTimerEvents_vtimes_set, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_vtimes_get", _wrap_ScopedTimerEvents_vtimes_get, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_names_set", _wrap_ScopedTimerEvents_names_set, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_names_get", _wrap_ScopedTimerEvents_names_get, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents__name_set", _wrap_ScopedTimerEvents__name_set, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents__name_get", _wrap_ScopedTimerEvents__name_get, METH_VARARGS, NULL}, + { (char *)"new_ScopedTimerEvents", _wrap_new_ScopedTimerEvents, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_add", _wrap_ScopedTimerEvents_add, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_addspaces", _wrap_ScopedTimerEvents_addspaces, METH_VARARGS, NULL}, + { (char *)"delete_ScopedTimerEvents", _wrap_delete_ScopedTimerEvents, METH_VARARGS, NULL}, + { (char *)"ScopedTimerEvents_swigregister", ScopedTimerEvents_swigregister, METH_VARARGS, NULL}, + { (char *)"Timer__s_set", _wrap_Timer__s_set, METH_VARARGS, NULL}, + { (char *)"Timer__s_get", _wrap_Timer__s_get, METH_VARARGS, NULL}, + { (char *)"Timer_sum_set", _wrap_Timer_sum_set, METH_VARARGS, NULL}, + { (char *)"Timer_sum_get", _wrap_Timer_sum_get, METH_VARARGS, NULL}, + { (char *)"Timer_n_set", _wrap_Timer_n_set, METH_VARARGS, NULL}, + { (char *)"Timer_n_get", _wrap_Timer_n_get, METH_VARARGS, NULL}, + { (char *)"Timer__name_set", _wrap_Timer__name_set, METH_VARARGS, NULL}, + { (char *)"Timer__name_get", _wrap_Timer__name_get, METH_VARARGS, NULL}, + { (char *)"new_Timer", _wrap_new_Timer, METH_VARARGS, NULL}, + { (char *)"Timer_setName", _wrap_Timer_setName, METH_VARARGS, NULL}, + { (char *)"Timer_start", _wrap_Timer_start, METH_VARARGS, NULL}, + { (char *)"Timer_end", _wrap_Timer_end, METH_VARARGS, NULL}, + { (char *)"Timer__print", _wrap_Timer__print, METH_VARARGS, NULL}, + { (char *)"Timer_getAverage", _wrap_Timer_getAverage, METH_VARARGS, NULL}, + { (char *)"delete_Timer", _wrap_delete_Timer, METH_VARARGS, NULL}, + { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_aruco__MarkerCandidateTo_p_aruco__Marker(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((aruco::Marker *) ((aruco::MarkerCandidate *) x)); +} +static void *_p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((std::vector< cv::Point2f,std::allocator< cv::Point2f > > *) ((aruco::Marker *) x)); +} +static void *_p_aruco__MarkerCandidateTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((std::vector< cv::Point2f,std::allocator< cv::Point2f > > *) (aruco::Marker *) ((aruco::MarkerCandidate *) x)); +} +static void *_p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *) ((aruco::MarkerMap *) x)); +} +static void *_p_aruco__SVMMarkersTo_p_aruco__MarkerLabeler(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((aruco::MarkerLabeler *) ((aruco::SVMMarkers *) x)); +} +static void *_p_aruco__DictionaryBasedTo_p_aruco__MarkerLabeler(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((aruco::MarkerLabeler *) ((aruco::DictionaryBased *) x)); +} +static swig_type_info _swigt__p_Marker = {"_p_Marker", "Marker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__CameraParameters = {"_p_aruco__CameraParameters", "aruco::CameraParameters *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__CvDrawingUtils = {"_p_aruco__CvDrawingUtils", "aruco::CvDrawingUtils *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__Debug = {"_p_aruco__Debug", "aruco::Debug *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__Dictionary = {"_p_aruco__Dictionary", "aruco::Dictionary *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__DictionaryBased = {"_p_aruco__DictionaryBased", "aruco::DictionaryBased *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__Marker = {"_p_aruco__Marker", "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *|aruco::Marker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__Marker3DInfo = {"_p_aruco__Marker3DInfo", "aruco::Marker3DInfo *|std::vector< aruco::Marker3DInfo >::value_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__MarkerCandidate = {"_p_aruco__MarkerCandidate", "aruco::MarkerCandidate *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__MarkerDetector = {"_p_aruco__MarkerDetector", "aruco::MarkerDetector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__MarkerLabeler = {"_p_aruco__MarkerLabeler", "aruco::MarkerLabeler *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__MarkerMap = {"_p_aruco__MarkerMap", "aruco::MarkerMap *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__MarkerMapPoseTracker = {"_p_aruco__MarkerMapPoseTracker", "aruco::MarkerMapPoseTracker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__MarkerPoseTracker = {"_p_aruco__MarkerPoseTracker", "aruco::MarkerPoseTracker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__Params = {"_p_aruco__Params", "aruco::Params *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__SVMMarkers = {"_p_aruco__SVMMarkers", "aruco::SVMMarkers *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__ScopeTimer = {"_p_aruco__ScopeTimer", "aruco::ScopeTimer *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__ScopedTimerEvents = {"_p_aruco__ScopedTimerEvents", "aruco::ScopedTimerEvents *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__Timer = {"_p_aruco__Timer", "aruco::Timer *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__Point2f = {"_p_cv__Point2f", "std::vector< cv::Point2f >::value_type *|cv::Point2f *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__Point3f = {"_p_cv__Point3f", "cv::Point3f *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__PtrT_aruco__MarkerLabeler_t = {"_p_cv__PtrT_aruco__MarkerLabeler_t", "cv::Ptr< aruco::MarkerLabeler > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__Size = {"_p_cv__Size", "cv::Size *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_aruco__Marker3DInfo_t = {"_p_std__allocatorT_aruco__Marker3DInfo_t", "std::vector< aruco::Marker3DInfo >::allocator_type *|std::allocator< aruco::Marker3DInfo > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_aruco__Marker_t = {"_p_std__allocatorT_aruco__Marker_t", "std::allocator< aruco::Marker > *|std::vector< aruco::Marker,std::allocator< aruco::Marker > >::allocator_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_cv__Point2f_t = {"_p_std__allocatorT_cv__Point2f_t", "std::vector< cv::Point2f >::allocator_type *|std::allocator< cv::Point2f > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__chrono__high_resolution_clock__time_point = {"_p_std__chrono__high_resolution_clock__time_point", "std::chrono::high_resolution_clock::time_point *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__mapT_uint64_t_uint16_t_t = {"_p_std__mapT_uint64_t_uint16_t_t", "std::map< uint64_t,uint16_t > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__pairT_cv__Mat_cv__Mat_t = {"_p_std__pairT_cv__Mat_cv__Mat_t", "std::pair< cv::Mat,cv::Mat > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t = {"_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t", "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *|std::vector< aruco::Marker3DInfo > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t = {"_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t", "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t = {"_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t", "std::vector< cv::Point2f > *|std::vector< cv::Point2f,std::allocator< cv::Point2f > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t = {"_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t", "std::vector< cv::Point3f,std::allocator< cv::Point3f > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t = {"_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t", "std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t = {"_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t", "std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_vectorT_aruco__Marker_t = {"_p_vectorT_aruco__Marker_t", "vector< aruco::Marker > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_vectorT_cv__Point3f_t = {"_p_vectorT_cv__Point3f_t", "vector< cv::Point3f > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_vectorT_cv__Point_t = {"_p_vectorT_cv__Point_t", "vector< cv::Point > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_vectorT_int_t = {"_p_vectorT_int_t", "vector< int > *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_Marker, + &_swigt__p_allocator_type, + &_swigt__p_aruco__CameraParameters, + &_swigt__p_aruco__CvDrawingUtils, + &_swigt__p_aruco__Debug, + &_swigt__p_aruco__Dictionary, + &_swigt__p_aruco__DictionaryBased, + &_swigt__p_aruco__Marker, + &_swigt__p_aruco__Marker3DInfo, + &_swigt__p_aruco__MarkerCandidate, + &_swigt__p_aruco__MarkerDetector, + &_swigt__p_aruco__MarkerLabeler, + &_swigt__p_aruco__MarkerMap, + &_swigt__p_aruco__MarkerMapPoseTracker, + &_swigt__p_aruco__MarkerPoseTracker, + &_swigt__p_aruco__Params, + &_swigt__p_aruco__SVMMarkers, + &_swigt__p_aruco__ScopeTimer, + &_swigt__p_aruco__ScopedTimerEvents, + &_swigt__p_aruco__Timer, + &_swigt__p_char, + &_swigt__p_cv__Point2f, + &_swigt__p_cv__Point3f, + &_swigt__p_cv__PtrT_aruco__MarkerLabeler_t, + &_swigt__p_cv__Size, + &_swigt__p_difference_type, + &_swigt__p_double, + &_swigt__p_int, + &_swigt__p_p_PyObject, + &_swigt__p_size_type, + &_swigt__p_std__allocatorT_aruco__Marker3DInfo_t, + &_swigt__p_std__allocatorT_aruco__Marker_t, + &_swigt__p_std__allocatorT_cv__Point2f_t, + &_swigt__p_std__allocatorT_int_t, + &_swigt__p_std__chrono__high_resolution_clock__time_point, + &_swigt__p_std__invalid_argument, + &_swigt__p_std__istream, + &_swigt__p_std__mapT_uint64_t_uint16_t_t, + &_swigt__p_std__ostream, + &_swigt__p_std__pairT_cv__Mat_cv__Mat_t, + &_swigt__p_std__string, + &_swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, + &_swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, + &_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, + &_swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, + &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, + &_swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, + &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, + &_swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, + &_swigt__p_swig__SwigPyIterator, + &_swigt__p_uint32_t, + &_swigt__p_uint64_t, + &_swigt__p_value_type, + &_swigt__p_vectorT_aruco__Marker_t, + &_swigt__p_vectorT_cv__Point3f_t, + &_swigt__p_vectorT_cv__Point_t, + &_swigt__p_vectorT_int_t, +}; + +static swig_cast_info _swigc__p_Marker[] = { {&_swigt__p_Marker, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__CameraParameters[] = { {&_swigt__p_aruco__CameraParameters, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__CvDrawingUtils[] = { {&_swigt__p_aruco__CvDrawingUtils, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Debug[] = { {&_swigt__p_aruco__Debug, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Dictionary[] = { {&_swigt__p_aruco__Dictionary, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__DictionaryBased[] = { {&_swigt__p_aruco__DictionaryBased, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Marker[] = { {&_swigt__p_aruco__MarkerCandidate, _p_aruco__MarkerCandidateTo_p_aruco__Marker, 0, 0}, {&_swigt__p_aruco__Marker, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Marker3DInfo[] = { {&_swigt__p_aruco__Marker3DInfo, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerCandidate[] = { {&_swigt__p_aruco__MarkerCandidate, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerDetector[] = { {&_swigt__p_aruco__MarkerDetector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerLabeler[] = { {&_swigt__p_aruco__SVMMarkers, _p_aruco__SVMMarkersTo_p_aruco__MarkerLabeler, 0, 0}, {&_swigt__p_aruco__MarkerLabeler, 0, 0, 0}, {&_swigt__p_aruco__DictionaryBased, _p_aruco__DictionaryBasedTo_p_aruco__MarkerLabeler, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerMap[] = { {&_swigt__p_aruco__MarkerMap, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerMapPoseTracker[] = { {&_swigt__p_aruco__MarkerMapPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerPoseTracker[] = { {&_swigt__p_aruco__MarkerPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Params[] = { {&_swigt__p_aruco__Params, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__SVMMarkers[] = { {&_swigt__p_aruco__SVMMarkers, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__ScopeTimer[] = { {&_swigt__p_aruco__ScopeTimer, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__ScopedTimerEvents[] = { {&_swigt__p_aruco__ScopedTimerEvents, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Timer[] = { {&_swigt__p_aruco__Timer, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__Point2f[] = { {&_swigt__p_cv__Point2f, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__Point3f[] = { {&_swigt__p_cv__Point3f, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__PtrT_aruco__MarkerLabeler_t[] = { {&_swigt__p_cv__PtrT_aruco__MarkerLabeler_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__Size[] = { {&_swigt__p_cv__Size, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_aruco__Marker3DInfo_t[] = { {&_swigt__p_std__allocatorT_aruco__Marker3DInfo_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_aruco__Marker_t[] = { {&_swigt__p_std__allocatorT_aruco__Marker_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_cv__Point2f_t[] = { {&_swigt__p_std__allocatorT_cv__Point2f_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_int_t[] = { {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__chrono__high_resolution_clock__time_point[] = { {&_swigt__p_std__chrono__high_resolution_clock__time_point, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__mapT_uint64_t_uint16_t_t[] = { {&_swigt__p_std__mapT_uint64_t_uint16_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__pairT_cv__Mat_cv__Mat_t[] = { {&_swigt__p_std__pairT_cv__Mat_cv__Mat_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0, 0}, {&_swigt__p_aruco__MarkerMap, _p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t[] = { {&_swigt__p_aruco__MarkerCandidate, _p_aruco__MarkerCandidateTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0}, {&_swigt__p_aruco__Marker, _p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0}, {&_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t[] = { {&_swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t[] = { {&_swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = { {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_uint64_t[] = { {&_swigt__p_uint64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_vectorT_aruco__Marker_t[] = { {&_swigt__p_vectorT_aruco__Marker_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_vectorT_cv__Point3f_t[] = { {&_swigt__p_vectorT_cv__Point3f_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_vectorT_cv__Point_t[] = { {&_swigt__p_vectorT_cv__Point_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_vectorT_int_t[] = { {&_swigt__p_vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_Marker, + _swigc__p_allocator_type, + _swigc__p_aruco__CameraParameters, + _swigc__p_aruco__CvDrawingUtils, + _swigc__p_aruco__Debug, + _swigc__p_aruco__Dictionary, + _swigc__p_aruco__DictionaryBased, + _swigc__p_aruco__Marker, + _swigc__p_aruco__Marker3DInfo, + _swigc__p_aruco__MarkerCandidate, + _swigc__p_aruco__MarkerDetector, + _swigc__p_aruco__MarkerLabeler, + _swigc__p_aruco__MarkerMap, + _swigc__p_aruco__MarkerMapPoseTracker, + _swigc__p_aruco__MarkerPoseTracker, + _swigc__p_aruco__Params, + _swigc__p_aruco__SVMMarkers, + _swigc__p_aruco__ScopeTimer, + _swigc__p_aruco__ScopedTimerEvents, + _swigc__p_aruco__Timer, + _swigc__p_char, + _swigc__p_cv__Point2f, + _swigc__p_cv__Point3f, + _swigc__p_cv__PtrT_aruco__MarkerLabeler_t, + _swigc__p_cv__Size, + _swigc__p_difference_type, + _swigc__p_double, + _swigc__p_int, + _swigc__p_p_PyObject, + _swigc__p_size_type, + _swigc__p_std__allocatorT_aruco__Marker3DInfo_t, + _swigc__p_std__allocatorT_aruco__Marker_t, + _swigc__p_std__allocatorT_cv__Point2f_t, + _swigc__p_std__allocatorT_int_t, + _swigc__p_std__chrono__high_resolution_clock__time_point, + _swigc__p_std__invalid_argument, + _swigc__p_std__istream, + _swigc__p_std__mapT_uint64_t_uint16_t_t, + _swigc__p_std__ostream, + _swigc__p_std__pairT_cv__Mat_cv__Mat_t, + _swigc__p_std__string, + _swigc__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, + _swigc__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, + _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, + _swigc__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, + _swigc__p_std__vectorT_int_std__allocatorT_int_t_t, + _swigc__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, + _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, + _swigc__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, + _swigc__p_swig__SwigPyIterator, + _swigc__p_uint32_t, + _swigc__p_uint64_t, + _swigc__p_value_type, + _swigc__p_vectorT_aruco__Marker_t, + _swigc__p_vectorT_cv__Point3f_t, + _swigc__p_vectorT_cv__Point_t, + _swigc__p_vectorT_int_t, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %d\n", swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; + } + + SWIGINTERN int + swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { + char *tmp; + PyObject *str = swig_varlink_str(v); + fprintf(fp,"Swig global variables "); + fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(str); + return 0; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { + /* PyObject header changed in Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + (char *)"swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ + (printfunc) swig_varlink_print, /* tp_print */ + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#if PY_VERSION_HEX >= 0x02060000 + 0, /* tp_version_tag */ +#endif +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ +#if PY_VERSION_HEX >= 0x02050000 + 0, /* tp_prev */ +#endif + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; +#if PY_VERSION_HEX < 0x02020000 + varlink_type.ob_type = &PyType_Type; +#else + if (PyType_Ready(&varlink_type) < 0) + return NULL; +#endif + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + strncpy(gv->name,name,size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *_SWIG_globals = 0; + if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); + return _SWIG_globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (!c) continue; + c = strstr(c, "swig_ptr: "); + if (c) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + strncpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + strncpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md; +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { +# if PY_VERSION_HEX >= 0x03020000 + PyModuleDef_HEAD_INIT, +# else + { + PyObject_HEAD_INIT(NULL) + NULL, /* m_init */ + 0, /* m_index */ + NULL, /* m_copy */ + }, +# endif + (char *) SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + (PyCFunction) SwigPyObject_own, + (PyCFunction) SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyObject *metatype_args; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + PyObject *self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* metatype is used to implement static member variables. */ + metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type); + assert(metatype_args); + metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL); + assert(metatype); + Py_DECREF(metatype_args); + metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro; + assert(PyType_Ready(metatype) >= 0); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule((char *) SWIG_name, SwigMethods); +#endif + + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce(); + } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + + import_array(); + + SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_36h12",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_36h12))); + SWIG_Python_SetConstant(d, "Dictionary_ARUCO",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO))); + SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_25h7",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_25h7))); + SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_16h3",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_16h3))); + SWIG_Python_SetConstant(d, "Dictionary_ARTAG",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARTAG))); + SWIG_Python_SetConstant(d, "Dictionary_ARTOOLKITPLUS",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARTOOLKITPLUS))); + SWIG_Python_SetConstant(d, "Dictionary_ARTOOLKITPLUSBCH",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARTOOLKITPLUSBCH))); + SWIG_Python_SetConstant(d, "Dictionary_TAG16h5",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG16h5))); + SWIG_Python_SetConstant(d, "Dictionary_TAG25h7",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG25h7))); + SWIG_Python_SetConstant(d, "Dictionary_TAG25h9",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG25h9))); + SWIG_Python_SetConstant(d, "Dictionary_TAG36h11",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG36h11))); + SWIG_Python_SetConstant(d, "Dictionary_TAG36h10",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG36h10))); + SWIG_Python_SetConstant(d, "Dictionary_CHILITAGS",SWIG_From_int(static_cast< int >(aruco::Dictionary::CHILITAGS))); + SWIG_Python_SetConstant(d, "Dictionary_CUSTOM",SWIG_From_int(static_cast< int >(aruco::Dictionary::CUSTOM))); + SWIG_Python_SetConstant(d, "Dictionary_ALL_DICTS",SWIG_From_int(static_cast< int >(aruco::Dictionary::ALL_DICTS))); + SWIG_Python_SetConstant(d, "MarkerMap_NONE",SWIG_From_int(static_cast< int >(aruco::MarkerMap::NONE))); + SWIG_Python_SetConstant(d, "MarkerMap_PIX",SWIG_From_int(static_cast< int >(aruco::MarkerMap::PIX))); + SWIG_Python_SetConstant(d, "MarkerMap_METERS",SWIG_From_int(static_cast< int >(aruco::MarkerMap::METERS))); + SWIG_Python_SetConstant(d, "ScopeTimer_NSEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::NSEC))); + SWIG_Python_SetConstant(d, "ScopeTimer_MSEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::MSEC))); + SWIG_Python_SetConstant(d, "ScopeTimer_SEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::SEC))); + SWIG_Python_SetConstant(d, "ScopedTimerEvents_NSEC",SWIG_From_int(static_cast< int >(aruco::ScopedTimerEvents::NSEC))); + SWIG_Python_SetConstant(d, "ScopedTimerEvents_MSEC",SWIG_From_int(static_cast< int >(aruco::ScopedTimerEvents::MSEC))); + SWIG_Python_SetConstant(d, "ScopedTimerEvents_SEC",SWIG_From_int(static_cast< int >(aruco::ScopedTimerEvents::SEC))); + SWIG_Python_SetConstant(d, "Timer_NSEC",SWIG_From_int(static_cast< int >(aruco::Timer::NSEC))); + SWIG_Python_SetConstant(d, "Timer_MSEC",SWIG_From_int(static_cast< int >(aruco::Timer::MSEC))); + SWIG_Python_SetConstant(d, "Timer_SEC",SWIG_From_int(static_cast< int >(aruco::Timer::SEC))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/aruco_wrap.h b/aruco_wrap.h new file mode 100644 index 0000000..918c0fd --- /dev/null +++ b/aruco_wrap.h @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 3.0.8 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_aruco_WRAP_H_ +#define SWIG_aruco_WRAP_H_ + +#include +#include + + +#endif diff --git a/setup.py b/setup.py index 8f096b9..28e4e8b 100644 --- a/setup.py +++ b/setup.py @@ -3,8 +3,8 @@ from distutils.core import setup, Extension -sourcefiles = ['aruco_wrap.cxx'] +sourcefiles = ['aruco_wrap.cxx'] aruco_module = Extension('_aruco', sources=sourcefiles, language="c++", @@ -14,9 +14,13 @@ library_dirs=["/usr/local/lib"]) setup(name='aruco', - version='3.0', + version='3.0.4', author="""ArUco: Rafael Muñoz Salinas, Python wrappers: Marcus Degenkolbe""", + author_email='marcus@degenkolbe.eu', description="""ArUco Python wrappers""", + url='https://github.com/fehlfarbe/python-aruco', + keywords='aruco wrapper', + install_requires=['numpy'], ext_modules=[aruco_module], py_modules=["aruco"], ) From f07eec4451798ad4514530b9db8a863f2bf4a60e Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Thu, 28 Dec 2017 18:45:52 +0100 Subject: [PATCH 02/22] Added pip support for python2/3 --- MANIFEST.in | 7 +- setup.py | 11 +- src/aruco.i | 221 ++++++++++++++++++ {aruco => src/include/aruco}/aruco.h | 0 {aruco => src/include/aruco}/aruco_export.h | 0 .../include/aruco}/cameraparameters.h | 0 {aruco => src/include/aruco}/cvdrawingutils.h | 0 {aruco => src/include/aruco}/debug.h | 0 {aruco => src/include/aruco}/dictionary.h | 0 {aruco => src/include/aruco}/ippe.h | 0 {aruco => src/include/aruco}/levmarq.h | 0 {aruco => src/include/aruco}/marker.h | 0 {aruco => src/include/aruco}/markerdetector.h | 0 {aruco => src/include/aruco}/markerlabeler.h | 0 .../aruco}/markerlabelers/dictionary_based.h | 0 .../aruco}/markerlabelers/svmmarkers.h | 0 {aruco => src/include/aruco}/markermap.h | 0 {aruco => src/include/aruco}/posetracker.h | 0 {aruco => src/include/aruco}/timers.h | 0 swigbuild.sh | 13 +- 20 files changed, 245 insertions(+), 7 deletions(-) create mode 100644 src/aruco.i rename {aruco => src/include/aruco}/aruco.h (100%) rename {aruco => src/include/aruco}/aruco_export.h (100%) rename {aruco => src/include/aruco}/cameraparameters.h (100%) rename {aruco => src/include/aruco}/cvdrawingutils.h (100%) rename {aruco => src/include/aruco}/debug.h (100%) rename {aruco => src/include/aruco}/dictionary.h (100%) rename {aruco => src/include/aruco}/ippe.h (100%) rename {aruco => src/include/aruco}/levmarq.h (100%) rename {aruco => src/include/aruco}/marker.h (100%) rename {aruco => src/include/aruco}/markerdetector.h (100%) rename {aruco => src/include/aruco}/markerlabeler.h (100%) rename {aruco => src/include/aruco}/markerlabelers/dictionary_based.h (100%) rename {aruco => src/include/aruco}/markerlabelers/svmmarkers.h (100%) rename {aruco => src/include/aruco}/markermap.h (100%) rename {aruco => src/include/aruco}/posetracker.h (100%) rename {aruco => src/include/aruco}/timers.h (100%) diff --git a/MANIFEST.in b/MANIFEST.in index daca31f..07c4ed6 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,3 +1,4 @@ -recursive-include aruco *.h -include aruco_wrap.cxx -include aruco_wrap.h \ No newline at end of file +recursive-include src * +recursive-include py2 * +recursive-include py3 * +include aruco_wrap.* \ No newline at end of file diff --git a/setup.py b/setup.py index 28e4e8b..e0fd740 100644 --- a/setup.py +++ b/setup.py @@ -2,19 +2,26 @@ # -*- coding: utf-8 -*- from distutils.core import setup, Extension +import shutil +import sys +# use python2/3 version of aruco +if sys.version_info[0] < 3: + shutil.copy("./py2/aruco.py", ".") +else: + shutil.copy("./py3/aruco.py", ".") sourcefiles = ['aruco_wrap.cxx'] aruco_module = Extension('_aruco', sources=sourcefiles, language="c++", extra_compile_args=["-std=c++11", "-Wall", "-fopenmp", "-Wunused-variable"], - include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "."], + include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "src/include/"], libraries=["opencv_core", "opencv_imgproc", "opencv_calib3d", "opencv_highgui", "aruco"], library_dirs=["/usr/local/lib"]) setup(name='aruco', - version='3.0.4', + version='3.0.4.1', author="""ArUco: Rafael Muñoz Salinas, Python wrappers: Marcus Degenkolbe""", author_email='marcus@degenkolbe.eu', description="""ArUco Python wrappers""", diff --git a/src/aruco.i b/src/aruco.i new file mode 100644 index 0000000..8680a8e --- /dev/null +++ b/src/aruco.i @@ -0,0 +1,221 @@ +/************************************ + +Swig Module for ArUco Python wrapper + +************************************/ + +// module name +%module(directors="1") aruco + +// needed +%include +%include "pyabc.i" +%include "std_vector.i" + +%{ + #define SWIG_FILE_WITH_INIT + using namespace std; +%} + +namespace std { + // for vector to Python list conversion + %template(VectorInt) vector; +}; + +// NumPy <--> OpenCV typemaps +%include "okapi-typemaps.i" +//%include +//%cv_instantiate_all_defaults + +/************************************ + +ArUco stuff + +************************************/ + + +%{ + #define SWIG_FILE_WITH_INIT + #include + #include + #include + #include + #include + #include + #include + //#include + #include + #include + #include + #include + #include + #include + #include + #include + + using namespace aruco; +%} + + + +%include +%include +%include +%include +%include +%include +//%include +%include + +// Marker is std::vector< cv::Point2f >, template definition +// needed for std::vector -> Python List conversion +%template(Point2fVec) std::vector< cv::Point2f >; +%template(MarkerVec) std::vector< aruco::Marker, std::allocator< aruco::Marker > >; +%template(VectorMarker3DInfo) std::vector< aruco::Marker3DInfo >; + +%include +/*** + Workaround: + std::vector.at() --> Point2f conversion doesn't work + so I just implemented the Python __getitem__() method for aruco::Marker + to get corner points of the Marker object and added VectorIterator to + support for-loops +***/ + +%pythoncode %{ +class VectorIterator(object): + + def __init__(self, pointerToVector): + self.pointerToVector = pointerToVector + self.index = -1 + + def __iter__(self): + return self + + def __next__(self): + self.index += 1 + if self.index < len(self.pointerToVector): + return self.pointerToVector[self.index] + else: + raise StopIteration + + def next(self): + self.index += 1 + if self.index < len(self.pointerToVector): + return self.pointerToVector[self.index] + else: + raise StopIteration +%} + +%extend aruco::Marker { + public: + cv::Point2f __getitem__(int i) { + return $self->at(i); + } +} + +%extend aruco::Marker { +%pythoncode { + def iterator(self): + return VectorIterator(self) + } +} + + +%include +%include +%include +%include +%include +%include +%include + + +/*************************************************************** + OLD STUFF +**************************************************************/ + +/* + +%extend aruco::BoardConfiguration { + public: + vector getIdList() { + vector list; + $self->getIdList(list); + return list; + } +} +*/ + +// Board is std::vector< aruco::Marker >, template definition +// needed for std::vector -> Python List conversion +/* +%template(MarkerVec) std::vector< aruco::Marker >; +%include "aruco/board.h" +%include "aruco/cvdrawingutils.h" +*/ + +// rename detect function because of polymorphism problems +//%rename("detect_mat") aruco::BoardDetector::detect(const cv::Mat&); + +// some stuff to support nested class MarkerCandidate in boarddetector.h + +// Suppress SWIG warning +//#pragma SWIG nowarn=SWIGWARN_PARSE_NESTED_CLASS +// nested class in markerdetector +/* +class MarkerCandidate : public aruco::Marker { + public: + MarkerCandidate() {} + MarkerCandidate(const aruco::Marker &M) : Maruco::arker(M) {} + MarkerCandidate(const MarkerCandidate &M) : aruco::Marker(M) { + contour = M.contour; + idx = M.idx; + } + MarkerCandidate &operator=(const MarkerCandidate &M) { + (*(aruco::Marker *)this) = (*(aruco::Marker *)&M); + contour = M.contour; + idx = M.idx; + return *this; + } + + vector< cv::Point > contour; // all the points of its contour + int idx; // index position in the global contour list +}; + +%{ + #include "aruco/markerdetector.h" +%} + +%include "aruco/markerdetector.h" +*/ +// add detect function that returns the detected markers +/* +%extend aruco::MarkerDetector { + + public: + std::vector< aruco::Marker > detect(const cv::Mat &input, + aruco::CameraParameters camParams, + float markerSizeMeters = -1, + bool setYPerperdicular = false) throw(cv::Exception) + { + std::vector< aruco::Marker > markers; + $self->detect(input, markers, camParams, markerSizeMeters, setYPerperdicular); + return markers; + }; +} + + + +%{ + // SWIG thinks that Inner is a global class, so we need to trick the C++ + // compiler into understanding this so called global type. + typedef aruco::MarkerDetector::MarkerCandidate MarkerCandidate; +%} + +%{ + #include "aruco/boarddetector.h" +%} + +%include "aruco/boarddetector.h" +*/ diff --git a/aruco/aruco.h b/src/include/aruco/aruco.h similarity index 100% rename from aruco/aruco.h rename to src/include/aruco/aruco.h diff --git a/aruco/aruco_export.h b/src/include/aruco/aruco_export.h similarity index 100% rename from aruco/aruco_export.h rename to src/include/aruco/aruco_export.h diff --git a/aruco/cameraparameters.h b/src/include/aruco/cameraparameters.h similarity index 100% rename from aruco/cameraparameters.h rename to src/include/aruco/cameraparameters.h diff --git a/aruco/cvdrawingutils.h b/src/include/aruco/cvdrawingutils.h similarity index 100% rename from aruco/cvdrawingutils.h rename to src/include/aruco/cvdrawingutils.h diff --git a/aruco/debug.h b/src/include/aruco/debug.h similarity index 100% rename from aruco/debug.h rename to src/include/aruco/debug.h diff --git a/aruco/dictionary.h b/src/include/aruco/dictionary.h similarity index 100% rename from aruco/dictionary.h rename to src/include/aruco/dictionary.h diff --git a/aruco/ippe.h b/src/include/aruco/ippe.h similarity index 100% rename from aruco/ippe.h rename to src/include/aruco/ippe.h diff --git a/aruco/levmarq.h b/src/include/aruco/levmarq.h similarity index 100% rename from aruco/levmarq.h rename to src/include/aruco/levmarq.h diff --git a/aruco/marker.h b/src/include/aruco/marker.h similarity index 100% rename from aruco/marker.h rename to src/include/aruco/marker.h diff --git a/aruco/markerdetector.h b/src/include/aruco/markerdetector.h similarity index 100% rename from aruco/markerdetector.h rename to src/include/aruco/markerdetector.h diff --git a/aruco/markerlabeler.h b/src/include/aruco/markerlabeler.h similarity index 100% rename from aruco/markerlabeler.h rename to src/include/aruco/markerlabeler.h diff --git a/aruco/markerlabelers/dictionary_based.h b/src/include/aruco/markerlabelers/dictionary_based.h similarity index 100% rename from aruco/markerlabelers/dictionary_based.h rename to src/include/aruco/markerlabelers/dictionary_based.h diff --git a/aruco/markerlabelers/svmmarkers.h b/src/include/aruco/markerlabelers/svmmarkers.h similarity index 100% rename from aruco/markerlabelers/svmmarkers.h rename to src/include/aruco/markerlabelers/svmmarkers.h diff --git a/aruco/markermap.h b/src/include/aruco/markermap.h similarity index 100% rename from aruco/markermap.h rename to src/include/aruco/markermap.h diff --git a/aruco/posetracker.h b/src/include/aruco/posetracker.h similarity index 100% rename from aruco/posetracker.h rename to src/include/aruco/posetracker.h diff --git a/aruco/timers.h b/src/include/aruco/timers.h similarity index 100% rename from aruco/timers.h rename to src/include/aruco/timers.h diff --git a/swigbuild.sh b/swigbuild.sh index cf53447..872b831 100755 --- a/swigbuild.sh +++ b/swigbuild.sh @@ -16,6 +16,15 @@ fi rm aruco.py &> /dev/null rm aruco_wrap.* &> /dev/null rm _aruco*.so &> /dev/null +rm -rf py2 &> /dev/null +rm -rf py3 &> /dev/null -# creates wrapper and builds shared library -swig -c++ -${SWIG_PYTHON} -I. -I/usr/local/include aruco.i && ${PYTHON_INTERPRETER} setup.py build_ext --inplace \ No newline at end of file +mkdir py2 &> /dev/null +mkdir py3 &> /dev/null + +# creates wrapper for py2 and py3 +swig -c++ -python -I./src/include -outdir py2 -I/usr/local/include aruco.i +swig -c++ -python -py3 -I./src/include -outdir py3 -I/usr/local/include aruco.i + +# builds shared library +${PYTHON_INTERPRETER} setup.py build_ext --inplace \ No newline at end of file From e3f59c87e5aeade762e53629255dbb66de78ce3f Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Sat, 16 Feb 2019 19:58:48 +0100 Subject: [PATCH 03/22] Removed -fopenmp for OSX --- setup.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index e0fd740..a9a1d71 100644 --- a/setup.py +++ b/setup.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- - +import platform from distutils.core import setup, Extension import shutil import sys @@ -11,17 +11,24 @@ else: shutil.copy("./py3/aruco.py", ".") + sourcefiles = ['aruco_wrap.cxx'] +extra_cpp_args = ["-std=c++11", "-Wall", "-Wunused-variable"] + +# Compiling on OSX does not work with openmp switch +if platform.system().lower() != "darwin": + extra_cpp_args.append("-fopenmp") + aruco_module = Extension('_aruco', sources=sourcefiles, language="c++", - extra_compile_args=["-std=c++11", "-Wall", "-fopenmp", "-Wunused-variable"], - include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "src/include/"], + extra_compile_args=extra_cpp_args, + include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "."], libraries=["opencv_core", "opencv_imgproc", "opencv_calib3d", "opencv_highgui", "aruco"], library_dirs=["/usr/local/lib"]) setup(name='aruco', - version='3.0.4.1', + version='3.0.4.2', author="""ArUco: Rafael Muñoz Salinas, Python wrappers: Marcus Degenkolbe""", author_email='marcus@degenkolbe.eu', description="""ArUco Python wrappers""", From 81f04f61b878cad0dc55b1b0b5cafe9eccfa06dd Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Tue, 26 Feb 2019 01:35:44 +0100 Subject: [PATCH 04/22] Updated to aruco 3.0.13 Added current aruco source code to the project so the only depedency is OpenCV (and numpy) --- README.md | 8 +- aruco_wrap.cxx | 3080 +++++++---------- aruco_wrap.h | 2 +- setup.py | 12 +- src/aruco/CMakeLists.txt | 56 + src/{include => }/aruco/aruco.h | 0 src/{include => }/aruco/aruco_export.h | 0 src/aruco/cameraparameters.cpp | 609 ++++ src/{include => }/aruco/cameraparameters.h | 15 +- src/aruco/cvdrawingutils.cpp | 174 + src/{include => }/aruco/cvdrawingutils.h | 6 +- src/aruco/debug.cpp | 67 + src/{include => }/aruco/debug.h | 0 src/aruco/dictionary.cpp | 538 +++ src/{include => }/aruco/dictionary.h | 59 +- src/aruco/ippe.cpp | 580 ++++ src/{include => }/aruco/ippe.h | 4 +- src/{include => }/aruco/levmarq.h | 0 src/aruco/marker.cpp | 476 +++ src/{include => }/aruco/marker.h | 4 +- src/aruco/markerdetector.cpp | 1649 +++++++++ src/{include => }/aruco/markerdetector.h | 330 +- src/aruco/markerlabeler.cpp | 77 + src/{include => }/aruco/markerlabeler.h | 2 +- src/aruco/markerlabelers/dictionary_based.cpp | 290 ++ .../aruco/markerlabelers/dictionary_based.h | 0 src/aruco/markerlabelers/svmmarkers.cpp | 179 + .../aruco/markerlabelers/svmmarkers.h | 0 src/aruco/markermap.cpp | 466 +++ src/{include => }/aruco/markermap.h | 4 +- src/aruco/picoflann.h | 709 ++++ src/aruco/posetracker.cpp | 559 +++ src/{include => }/aruco/posetracker.h | 11 +- src/{include => }/aruco/timers.h | 0 swigbuild.sh | 4 +- 35 files changed, 7894 insertions(+), 2076 deletions(-) create mode 100644 src/aruco/CMakeLists.txt rename src/{include => }/aruco/aruco.h (100%) rename src/{include => }/aruco/aruco_export.h (100%) create mode 100644 src/aruco/cameraparameters.cpp rename src/{include => }/aruco/cameraparameters.h (94%) create mode 100644 src/aruco/cvdrawingutils.cpp rename src/{include => }/aruco/cvdrawingutils.h (95%) create mode 100644 src/aruco/debug.cpp rename src/{include => }/aruco/debug.h (100%) create mode 100644 src/aruco/dictionary.cpp rename src/{include => }/aruco/dictionary.h (78%) create mode 100644 src/aruco/ippe.cpp rename src/{include => }/aruco/ippe.h (97%) rename src/{include => }/aruco/levmarq.h (100%) create mode 100644 src/aruco/marker.cpp rename src/{include => }/aruco/marker.h (98%) create mode 100644 src/aruco/markerdetector.cpp rename src/{include => }/aruco/markerdetector.h (59%) create mode 100644 src/aruco/markerlabeler.cpp rename src/{include => }/aruco/markerlabeler.h (99%) create mode 100644 src/aruco/markerlabelers/dictionary_based.cpp rename src/{include => }/aruco/markerlabelers/dictionary_based.h (100%) create mode 100755 src/aruco/markerlabelers/svmmarkers.cpp rename src/{include => }/aruco/markerlabelers/svmmarkers.h (100%) mode change 100644 => 100755 create mode 100644 src/aruco/markermap.cpp rename src/{include => }/aruco/markermap.h (98%) create mode 100644 src/aruco/picoflann.h create mode 100644 src/aruco/posetracker.cpp rename src/{include => }/aruco/posetracker.h (93%) rename src/{include => }/aruco/timers.h (100%) diff --git a/README.md b/README.md index fd91b88..c16b31b 100644 --- a/README.md +++ b/README.md @@ -2,19 +2,17 @@ [SWIG](http://www.swig.org/) generated Python wrappers for ArUco library. Works with OpenCV Python module cv2 resp. numpy array data types. -Tested on Linux Mint 18.2 x86_64, OpenCV 3.3.1, ArUco 3.0.4, Python 2.7.6 and NumPy 1.10.4 +Tested on Linux Mint 19 x86_64, OpenCV 3.4.5, ArUco 3.0.13 Python 2.7.15 and NumPy 1.13.3 Installation via pip -------------------- 1. Install / compile [OpenCV](http://opencv.org/) >= 3.3.1 with Python2 support -2. download, compile and install ArUco 3 : http://www.uco.es/investiga/grupos/ava/node/26, -3. run `sudo -H pip install aruco` +2. run `sudo -H pip install aruco` Installation Python2 -------------------- 1. Install / compile [OpenCV](http://opencv.org/) >= 2.4.9 with Python2 support -2. download, compile and install ArUco: http://www.uco.es/investiga/grupos/ava/node/26, 3. Install swig3: `sudo apt-get install swig3.0` for Debian/Ubuntu like systems 4. Install NumPy `sudo pip install numpy` (maybe you already need it for OpenCV Python support) or install via system packet manager 5. run `./swigbuild.sh`: it compiles the shared library (_aruco.so) and generates Python wrappers (aruco.py) @@ -23,9 +21,7 @@ Installation Python2 Installation Python3 (experimental) ----------------------------------- -Tested on Ubuntu 16.04, OpenCV 3.3.1, Python3.5, Aruco 3.0.4 1. Install / compile [OpenCV](http://opencv.org/) >= 2.4.9 with Python3 support. [Install-OpenCV script helps to install the latest version.](https://github.com/jayrambhia/Install-OpenCV/) -2. download, compile and install ArUco: http://www.uco.es/investiga/grupos/ava/node/26: 3. Install swig3: `sudo apt-get install swig3.0` for Debian/Ubuntu like systems. On 14.04 and other older systems you will need to go to "Software Sources" and check backports in the Updates tab, and reload before installing. 4. Install NumPy `sudo pip3 install numpy` (maybe you already need it for OpenCV Python support) or install via system package manager. 5. run `./swigbuild.sh python3`: it compiles the shared library (_aruco.so) and generates Python3 wrappers (aruco.py) diff --git a/aruco_wrap.cxx b/aruco_wrap.cxx index 8245f6f..87c10de 100644 --- a/aruco_wrap.cxx +++ b/aruco_wrap.cxx @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.8 + * Version 3.0.12 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make @@ -107,9 +107,11 @@ template T SwigValueInit() { #endif /* exporting methods */ -#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -# ifndef GCC_HASCLASSVISIBILITY -# define GCC_HASCLASSVISIBILITY +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif # endif #endif @@ -669,16 +671,16 @@ SWIG_UnpackData(const char *c, void *ptr, size_t sz) { char d = *(c++); unsigned char uu; if ((d >= '0') && (d <= '9')) - uu = ((d - '0') << 4); + uu = (unsigned char)((d - '0') << 4); else if ((d >= 'a') && (d <= 'f')) - uu = ((d - ('a'-10)) << 4); + uu = (unsigned char)((d - ('a'-10)) << 4); else return (char *) 0; d = *(c++); if ((d >= '0') && (d <= '9')) - uu |= (d - '0'); + uu |= (unsigned char)(d - '0'); else if ((d >= 'a') && (d <= 'f')) - uu |= (d - ('a'-10)); + uu |= (unsigned char)(d - ('a'-10)); else return (char *) 0; *u = uu; @@ -861,10 +863,6 @@ PyString_FromFormat(const char *fmt, ...) { } #endif -/* Add PyObject_Del for old Pythons */ -#if PY_VERSION_HEX < 0x01060000 -# define PyObject_Del(op) PyMem_DEL((op)) -#endif #ifndef PyObject_DEL # define PyObject_DEL PyObject_Del #endif @@ -979,6 +977,7 @@ typedef destructor freefunc; #if PY_VERSION_HEX < 0x03020000 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define Py_hash_t long #endif /* ----------------------------------------------------------------------------- @@ -1927,7 +1926,6 @@ SwigPyObject_TypeOnce(void) { static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { - /* PyObject header changed in Python 3 */ #if PY_VERSION_HEX >= 0x03000000 PyVarObject_HEAD_INIT(NULL, 0) #else @@ -1938,7 +1936,7 @@ SwigPyObject_TypeOnce(void) { sizeof(SwigPyObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyObject_dealloc, /* tp_dealloc */ - 0, /* tp_print */ + 0, /* tp_print */ #if PY_VERSION_HEX < 0x02020000 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ #else @@ -1946,7 +1944,7 @@ SwigPyObject_TypeOnce(void) { #endif (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX >= 0x03000000 - 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ #else (cmpfunc)SwigPyObject_compare, /* tp_compare */ #endif @@ -1956,7 +1954,7 @@ SwigPyObject_TypeOnce(void) { 0, /* tp_as_mapping */ (hashfunc)0, /* tp_hash */ (ternaryfunc)0, /* tp_call */ - 0, /* tp_str */ + 0, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ @@ -2119,7 +2117,6 @@ SwigPyPacked_TypeOnce(void) { static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { - /* PyObject header changed in Python 3 */ #if PY_VERSION_HEX>=0x03000000 PyVarObject_HEAD_INIT(NULL, 0) #else @@ -3463,56 +3460,55 @@ namespace Swig { #define SWIGTYPE_p_aruco__DictionaryBased swig_types[6] #define SWIGTYPE_p_aruco__Marker swig_types[7] #define SWIGTYPE_p_aruco__Marker3DInfo swig_types[8] -#define SWIGTYPE_p_aruco__MarkerCandidate swig_types[9] -#define SWIGTYPE_p_aruco__MarkerDetector swig_types[10] +#define SWIGTYPE_p_aruco__MarkerDetector swig_types[9] +#define SWIGTYPE_p_aruco__MarkerDetector__Params swig_types[10] #define SWIGTYPE_p_aruco__MarkerLabeler swig_types[11] #define SWIGTYPE_p_aruco__MarkerMap swig_types[12] #define SWIGTYPE_p_aruco__MarkerMapPoseTracker swig_types[13] #define SWIGTYPE_p_aruco__MarkerPoseTracker swig_types[14] -#define SWIGTYPE_p_aruco__Params swig_types[15] -#define SWIGTYPE_p_aruco__SVMMarkers swig_types[16] -#define SWIGTYPE_p_aruco__ScopeTimer swig_types[17] -#define SWIGTYPE_p_aruco__ScopedTimerEvents swig_types[18] -#define SWIGTYPE_p_aruco__Timer swig_types[19] -#define SWIGTYPE_p_char swig_types[20] -#define SWIGTYPE_p_cv__Point2f swig_types[21] -#define SWIGTYPE_p_cv__Point3f swig_types[22] -#define SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t swig_types[23] -#define SWIGTYPE_p_cv__Size swig_types[24] -#define SWIGTYPE_p_difference_type swig_types[25] -#define SWIGTYPE_p_double swig_types[26] -#define SWIGTYPE_p_int swig_types[27] -#define SWIGTYPE_p_p_PyObject swig_types[28] -#define SWIGTYPE_p_size_type swig_types[29] -#define SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t swig_types[30] -#define SWIGTYPE_p_std__allocatorT_aruco__Marker_t swig_types[31] -#define SWIGTYPE_p_std__allocatorT_cv__Point2f_t swig_types[32] -#define SWIGTYPE_p_std__allocatorT_int_t swig_types[33] -#define SWIGTYPE_p_std__chrono__high_resolution_clock__time_point swig_types[34] -#define SWIGTYPE_p_std__invalid_argument swig_types[35] -#define SWIGTYPE_p_std__istream swig_types[36] -#define SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t swig_types[37] -#define SWIGTYPE_p_std__ostream swig_types[38] -#define SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t swig_types[39] -#define SWIGTYPE_p_std__string swig_types[40] -#define SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t swig_types[41] -#define SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t swig_types[42] -#define SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t swig_types[43] -#define SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t swig_types[44] -#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[45] -#define SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t swig_types[46] -#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[47] -#define SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t swig_types[48] -#define SWIGTYPE_p_swig__SwigPyIterator swig_types[49] -#define SWIGTYPE_p_uint32_t swig_types[50] -#define SWIGTYPE_p_uint64_t swig_types[51] -#define SWIGTYPE_p_value_type swig_types[52] -#define SWIGTYPE_p_vectorT_aruco__Marker_t swig_types[53] -#define SWIGTYPE_p_vectorT_cv__Point3f_t swig_types[54] -#define SWIGTYPE_p_vectorT_cv__Point_t swig_types[55] -#define SWIGTYPE_p_vectorT_int_t swig_types[56] -static swig_type_info *swig_types[58]; -static swig_module_info swig_module = {swig_types, 57, 0, 0, 0, 0}; +#define SWIGTYPE_p_aruco__SVMMarkers swig_types[15] +#define SWIGTYPE_p_aruco__ScopeTimer swig_types[16] +#define SWIGTYPE_p_aruco__ScopedTimerEvents swig_types[17] +#define SWIGTYPE_p_aruco__Timer swig_types[18] +#define SWIGTYPE_p_char swig_types[19] +#define SWIGTYPE_p_cv__Point2f swig_types[20] +#define SWIGTYPE_p_cv__Point3f swig_types[21] +#define SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t swig_types[22] +#define SWIGTYPE_p_cv__Size swig_types[23] +#define SWIGTYPE_p_difference_type swig_types[24] +#define SWIGTYPE_p_double swig_types[25] +#define SWIGTYPE_p_int swig_types[26] +#define SWIGTYPE_p_p_PyObject swig_types[27] +#define SWIGTYPE_p_size_type swig_types[28] +#define SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t swig_types[29] +#define SWIGTYPE_p_std__allocatorT_aruco__Marker_t swig_types[30] +#define SWIGTYPE_p_std__allocatorT_cv__Point2f_t swig_types[31] +#define SWIGTYPE_p_std__allocatorT_int_t swig_types[32] +#define SWIGTYPE_p_std__chrono__high_resolution_clock__time_point swig_types[33] +#define SWIGTYPE_p_std__invalid_argument swig_types[34] +#define SWIGTYPE_p_std__istream swig_types[35] +#define SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t swig_types[36] +#define SWIGTYPE_p_std__ostream swig_types[37] +#define SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t swig_types[38] +#define SWIGTYPE_p_std__string swig_types[39] +#define SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t swig_types[40] +#define SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t swig_types[41] +#define SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t swig_types[42] +#define SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t swig_types[43] +#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[44] +#define SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t swig_types[45] +#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[46] +#define SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t swig_types[47] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[48] +#define SWIGTYPE_p_uint32_t swig_types[49] +#define SWIGTYPE_p_uint64_t swig_types[50] +#define SWIGTYPE_p_value_type swig_types[51] +#define SWIGTYPE_p_vectorT_aruco__Marker_t swig_types[52] +#define SWIGTYPE_p_vectorT_cv__Point3f_t swig_types[53] +#define SWIGTYPE_p_vectorT_cv__Point_t swig_types[54] +#define SWIGTYPE_p_vectorT_int_t swig_types[55] +static swig_type_info *swig_types[57]; +static swig_module_info swig_module = {swig_types, 56, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3536,7 +3532,7 @@ static swig_module_info swig_module = {swig_types, 57, 0, 0, 0, 0}; #endif #define SWIG_name "_aruco" -#define SWIGVERSION 0x030008 +#define SWIGVERSION 0x030012 #define SWIG_VERSION SWIGVERSION @@ -3629,6 +3625,7 @@ namespace swig { #endif +#include #include @@ -3778,7 +3775,7 @@ SWIG_AsVal_double (PyObject *obj, double *val) return SWIG_OK; #if PY_VERSION_HEX < 0x03000000 } else if (PyInt_Check(obj)) { - if (val) *val = PyInt_AsLong(obj); + if (val) *val = (double) PyInt_AsLong(obj); return SWIG_OK; #endif } else if (PyLong_Check(obj)) { @@ -3899,23 +3896,109 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) } +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE) +# define SWIG_LONG_LONG_AVAILABLE +#endif + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERN int +SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val) +{ + int res = SWIG_TypeError; + if (PyLong_Check(obj)) { + unsigned long long v = PyLong_AsUnsignedLongLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + res = SWIG_OverflowError; + } + } else { + unsigned long v; + res = SWIG_AsVal_unsigned_SS_long (obj,&v); + if (SWIG_IsOK(res)) { + if (val) *val = v; + return res; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + const double mant_max = 1LL << DBL_MANT_DIG; + double d; + res = SWIG_AsVal_double (obj,&d); + if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max)) + return SWIG_OverflowError; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) { + if (val) *val = (unsigned long long)(d); + return SWIG_AddCast(res); + } + res = SWIG_TypeError; + } +#endif + return res; +} +#endif + + SWIGINTERNINLINE int SWIG_AsVal_size_t (PyObject * obj, size_t *val) { - unsigned long v; - int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); - if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); + int res = SWIG_TypeError; +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(size_t) <= sizeof(unsigned long)) { +#endif + unsigned long v; + res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else if (sizeof(size_t) <= sizeof(unsigned long long)) { + unsigned long long v; + res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); + } +#endif return res; } - #define SWIG_From_long PyLong_FromLong + #define SWIG_From_long PyInt_FromLong + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERNINLINE PyObject* +SWIG_From_long_SS_long (long long value) +{ + return ((value < LONG_MIN) || (value > LONG_MAX)) ? + PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value)); +} +#endif SWIGINTERNINLINE PyObject * SWIG_From_ptrdiff_t (ptrdiff_t value) { - return SWIG_From_long (static_cast< long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(ptrdiff_t) <= sizeof(long)) { +#endif + return SWIG_From_long (static_cast< long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else { + /* assume sizeof(ptrdiff_t) <= sizeof(long long) */ + return SWIG_From_long_SS_long (static_cast< long long >(value)); + } +#endif } @@ -3969,12 +4052,65 @@ SWIG_AsVal_long (PyObject *obj, long* val) } +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERN int +SWIG_AsVal_long_SS_long (PyObject *obj, long long *val) +{ + int res = SWIG_TypeError; + if (PyLong_Check(obj)) { + long long v = PyLong_AsLongLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + res = SWIG_OverflowError; + } + } else { + long v; + res = SWIG_AsVal_long (obj,&v); + if (SWIG_IsOK(res)) { + if (val) *val = v; + return res; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + const double mant_max = 1LL << DBL_MANT_DIG; + const double mant_min = -mant_max; + double d; + res = SWIG_AsVal_double (obj,&d); + if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max)) + return SWIG_OverflowError; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) { + if (val) *val = (long long)(d); + return SWIG_AddCast(res); + } + res = SWIG_TypeError; + } +#endif + return res; +} +#endif + + SWIGINTERNINLINE int SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val) { - long v; - int res = SWIG_AsVal_long (obj, val ? &v : 0); - if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); + int res = SWIG_TypeError; +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(ptrdiff_t) <= sizeof(long)) { +#endif + long v; + res = SWIG_AsVal_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else if (sizeof(ptrdiff_t) <= sizeof(long long)) { + long long v; + res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); + } +#endif return res; } @@ -4016,8 +4152,21 @@ namespace swig { return traits::noconst_type >::type_name(); } - template - struct traits_info { + template struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; + } + }; + + /* + Partial specialization for pointers (traits_info) + */ + template struct traits_info { static swig_type_info *type_query(std::string name) { name += " *"; return SWIG_TypeQuery(name.c_str()); @@ -4034,7 +4183,7 @@ namespace swig { } /* - Partial specialization for pointers + Partial specialization for pointers (traits) */ template struct traits { typedef pointer_category category; @@ -4104,7 +4253,8 @@ namespace swig { struct traits_asptr { static int asptr(PyObject *obj, Type **val) { Type *p; - int res = SWIG_ConvertPtr(obj, (void**)&p, type_info(), 0); + swig_type_info *descriptor = type_info(); + int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR; if (SWIG_IsOK(res)) { if (val) *val = p; } @@ -4252,7 +4402,7 @@ namespace swig { namespace std { template <> - struct less : public binary_function + struct less { bool operator()(PyObject * v, PyObject *w) const @@ -4277,7 +4427,7 @@ namespace std { }; template <> - struct less : public binary_function + struct less { bool operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const @@ -4287,7 +4437,7 @@ namespace std { }; template <> - struct less : public binary_function + struct less { bool operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const @@ -4350,7 +4500,7 @@ namespace swig { if (step == 0) { throw std::invalid_argument("slice step cannot be zero"); } else if (step > 0) { - // Required range: 0 <= i < size, 0 <= j < size + // Required range: 0 <= i < size, 0 <= j < size, i <= j if (i < 0) { ii = 0; } else if (i < (Difference)size) { @@ -4358,13 +4508,15 @@ namespace swig { } else if (insert && (i >= (Difference)size)) { ii = (Difference)size; } - if ( j < 0 ) { + if (j < 0) { jj = 0; } else { jj = (j < (Difference)size) ? j : (Difference)size; } + if (jj < ii) + jj = ii; } else { - // Required range: -1 <= i < size-1, -1 <= j < size-1 + // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j if (i < -1) { ii = -1; } else if (i < (Difference) size) { @@ -4377,6 +4529,8 @@ namespace swig { } else { jj = (j < (Difference)size ) ? j : (Difference)(size-1); } + if (ii < jj) + ii = jj; } } @@ -4402,6 +4556,13 @@ namespace swig { seq->erase(position); } + template + struct traits_reserve { + static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) { + // This should be specialized for types that support reserve + } + }; + template inline Sequence* getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) { @@ -4419,6 +4580,7 @@ namespace swig { return new Sequence(sb, se); } else { Sequence *sequence = new Sequence(); + swig::traits_reserve::reserve(*sequence, (jj - ii + step - 1) / step); typename Sequence::const_iterator it = sb; while (it!=se) { sequence->push_back(*it); @@ -4429,17 +4591,16 @@ namespace swig { } } else { Sequence *sequence = new Sequence(); - if (ii > jj) { - typename Sequence::const_reverse_iterator sb = self->rbegin(); - typename Sequence::const_reverse_iterator se = self->rbegin(); - std::advance(sb,size-ii-1); - std::advance(se,size-jj-1); - typename Sequence::const_reverse_iterator it = sb; - while (it!=se) { - sequence->push_back(*it); - for (Py_ssize_t c=0; c<-step && it!=se; ++c) - it++; - } + swig::traits_reserve::reserve(*sequence, (ii - jj - step - 1) / -step); + typename Sequence::const_reverse_iterator sb = self->rbegin(); + typename Sequence::const_reverse_iterator se = self->rbegin(); + std::advance(sb,size-ii-1); + std::advance(se,size-jj-1); + typename Sequence::const_reverse_iterator it = sb; + while (it!=se) { + sequence->push_back(*it); + for (Py_ssize_t c=0; c<-step && it!=se; ++c) + it++; } return sequence; } @@ -4453,12 +4614,11 @@ namespace swig { Difference jj = 0; swig::slice_adjust(i, j, step, size, ii, jj, true); if (step > 0) { - if (jj < ii) - jj = ii; if (step == 1) { size_t ssize = jj - ii; if (ssize <= is.size()) { // expanding/staying the same size + swig::traits_reserve::reserve(*self, self->size() - ssize + is.size()); typename Sequence::iterator sb = self->begin(); typename InputSeq::const_iterator isit = is.begin(); std::advance(sb,ii); @@ -4492,8 +4652,6 @@ namespace swig { } } } else { - if (jj > ii) - jj = ii; size_t replacecount = (ii - jj - step - 1) / -step; if (is.size() != replacecount) { char msg[1024]; @@ -4519,37 +4677,33 @@ namespace swig { Difference jj = 0; swig::slice_adjust(i, j, step, size, ii, jj, true); if (step > 0) { - if (jj > ii) { - typename Sequence::iterator sb = self->begin(); - std::advance(sb,ii); - if (step == 1) { - typename Sequence::iterator se = self->begin(); - std::advance(se,jj); - self->erase(sb,se); - } else { - typename Sequence::iterator it = sb; - size_t delcount = (jj - ii + step - 1) / step; - while (delcount) { - it = self->erase(it); - for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) - it++; - delcount--; - } - } - } - } else { - if (ii > jj) { - typename Sequence::reverse_iterator sb = self->rbegin(); - std::advance(sb,size-ii-1); - typename Sequence::reverse_iterator it = sb; - size_t delcount = (ii - jj - step - 1) / -step; + typename Sequence::iterator sb = self->begin(); + std::advance(sb,ii); + if (step == 1) { + typename Sequence::iterator se = self->begin(); + std::advance(se,jj); + self->erase(sb,se); + } else { + typename Sequence::iterator it = sb; + size_t delcount = (jj - ii + step - 1) / step; while (delcount) { - it = typename Sequence::reverse_iterator(self->erase((++it).base())); - for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) + it = self->erase(it); + for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) it++; delcount--; } } + } else { + typename Sequence::reverse_iterator sb = self->rbegin(); + std::advance(sb,size-ii-1); + typename Sequence::reverse_iterator it = sb; + size_t delcount = (ii - jj - step - 1) / -step; + while (delcount) { + it = typename Sequence::reverse_iterator(self->erase((++it).base())); + for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) + it++; + delcount--; + } } } } @@ -5005,16 +5159,6 @@ namespace swig } -#include -#if !defined(SWIG_NO_LLONG_MAX) -# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) -# define LLONG_MAX __LONG_LONG_MAX__ -# define LLONG_MIN (-LLONG_MAX - 1LL) -# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) -# endif -#endif - - SWIGINTERN int SWIG_AsVal_int (PyObject * obj, int *val) { @@ -5078,8 +5222,8 @@ namespace swig { static int asptr(PyObject *obj, sequence **seq) { if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) { sequence *p; - if (::SWIG_ConvertPtr(obj,(void**)&p, - swig::type_info(),0) == SWIG_OK) { + swig_type_info *descriptor = swig::type_info(); + if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) { if (seq) *seq = p; return SWIG_OLDOBJ; } @@ -5118,7 +5262,7 @@ namespace swig { #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS swig_type_info *desc = swig::type_info(); if (desc && desc->clientdata) { - return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); + return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); } #endif size_type size = seq.size(); @@ -5139,6 +5283,13 @@ namespace swig { namespace swig { + template + struct traits_reserve > { + static void reserve(std::vector &seq, typename std::vector::size_type n) { + seq.reserve(n); + } + }; + template struct traits_asptr > { static int asptr(PyObject *obj, std::vector **vec) { @@ -5181,14 +5332,33 @@ SWIGINTERNINLINE PyObject* SWIG_From_unsigned_SS_long (unsigned long value) { return (value > LONG_MAX) ? - PyLong_FromUnsignedLong(value) : PyLong_FromLong(static_cast< long >(value)); + PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); +} + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long_SS_long (unsigned long long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value)); } +#endif SWIGINTERNINLINE PyObject * SWIG_From_size_t (size_t value) { - return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(size_t) <= sizeof(unsigned long)) { +#endif + return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else { + /* assume sizeof(size_t) <= sizeof(unsigned long long) */ + return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value)); + } +#endif } SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ @@ -5954,13 +6124,18 @@ SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) { #if PY_VERSION_HEX>=0x03000000 +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + if (PyBytes_Check(obj)) +#else if (PyUnicode_Check(obj)) +#endif #else if (PyString_Check(obj)) #endif { char *cstr; Py_ssize_t len; #if PY_VERSION_HEX>=0x03000000 +#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) if (!alloc && cptr) { /* We can't allow converting without allocation, since the internal representation of string in Python 3 is UCS-2/UCS-4 but we require @@ -5969,8 +6144,9 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) return SWIG_RuntimeError; } obj = PyUnicode_AsUTF8String(obj); - PyBytes_AsStringAndSize(obj, &cstr, &len); if(alloc) *alloc = SWIG_NEWOBJ; +#endif + PyBytes_AsStringAndSize(obj, &cstr, &len); #else PyString_AsStringAndSize(obj, &cstr, &len); #endif @@ -5991,26 +6167,34 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) if (*alloc == SWIG_NEWOBJ) #endif { - *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1))); + *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); *alloc = SWIG_NEWOBJ; } else { *cptr = cstr; *alloc = SWIG_OLDOBJ; } } else { - #if PY_VERSION_HEX>=0x03000000 - assert(0); /* Should never reach here in Python 3 */ - #endif +#if PY_VERSION_HEX>=0x03000000 +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + *cptr = PyBytes_AsString(obj); +#else + assert(0); /* Should never reach here with Unicode strings in Python 3 */ +#endif +#else *cptr = SWIG_Python_str_AsChar(obj); +#endif } } if (psize) *psize = len + 1; -#if PY_VERSION_HEX>=0x03000000 +#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) Py_XDECREF(obj); #endif return SWIG_OK; } else { #if defined(SWIG_PYTHON_2_UNICODE) +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) +#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once" +#endif #if PY_VERSION_HEX<0x03000000 if (PyUnicode_Check(obj)) { char *cstr; Py_ssize_t len; @@ -6021,7 +6205,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) { if (cptr) { if (alloc) *alloc = SWIG_NEWOBJ; - *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1))); + *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); } if (psize) *psize = len + 1; @@ -6096,8 +6280,25 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) /* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */ #ifndef SWIG_isfinite +/* isfinite() is a macro for C99 */ # if defined(isfinite) # define SWIG_isfinite(X) (isfinite(X)) +# elif defined __cplusplus && __cplusplus >= 201103L +/* Use a template so that this works whether isfinite() is std::isfinite() or + * in the global namespace. The reality seems to vary between compiler + * versions. + * + * Make sure namespace std exists to avoid compiler warnings. + * + * extern "C++" is required as this fragment can end up inside an extern "C" { } block + */ +namespace std { } +extern "C++" template +inline int SWIG_isfinite_func(T x) { + using namespace std; + return isfinite(x); +} +# define SWIG_isfinite(X) (SWIG_isfinite_func(X)) # elif defined(_MSC_VER) # define SWIG_isfinite(X) (_finite(X)) # elif defined(__sun) && defined(__SVR4) @@ -6141,11 +6342,15 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size) SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); } else { #if PY_VERSION_HEX >= 0x03000000 +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#else #if PY_VERSION_HEX >= 0x03010000 return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); #else return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); #endif +#endif #else return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); #endif @@ -7358,7 +7563,7 @@ SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -9276,33 +9481,11 @@ SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyOb SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ARUCO_VERSION_MAJOR_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *module; - PyObject *d; - if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; - d = PyModule_GetDict(module); - if (!d) return NULL; - SWIG_Python_SetConstant(d, "ARUCO_VERSION_MAJOR",SWIG_From_int(static_cast< int >(3))); - return SWIG_Py_Void(); -} - - -SWIGINTERN PyObject *ARUCO_VERSION_MINOR_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *module; - PyObject *d; - if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; - d = PyModule_GetDict(module); - if (!d) return NULL; - SWIG_Python_SetConstant(d, "ARUCO_VERSION_MINOR",SWIG_From_int(static_cast< int >(0))); - return SWIG_Py_Void(); -} - - SWIGINTERN PyObject *_wrap_CameraParameters_CameraMatrix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; @@ -9943,28 +10126,24 @@ SWIGINTERN PyObject *_wrap_CameraParameters_resize(PyObject *SWIGUNUSEDPARM(self SWIGINTERN PyObject *_wrap_CameraParameters_getCameraLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cv::Mat arg1 ; - cv::Mat arg2 ; - cv::Mat *mat1 ; - cv::Mat *mat2 ; + cv::Mat *arg1 = 0 ; + cv::Mat *arg2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; cv::Point3f result; if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_getCameraLocation",&obj0,&obj1)) SWIG_fail; { - mat1 = array_to_mat(obj0); - if (mat1 == NULL) + arg1 = array_to_mat(obj0); + if (arg1 == NULL) SWIG_fail; - arg1 = *mat1; } { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) + arg2 = array_to_mat(obj1); + if (arg2 == NULL) SWIG_fail; - arg2 = *mat2; } - result = aruco::CameraParameters::getCameraLocation(arg1,arg2); + result = aruco::CameraParameters::getCameraLocation((cv::Mat const &)*arg1,(cv::Mat const &)*arg2); resultobj = SWIG_NewPointerObj((new cv::Point3f(static_cast< const cv::Point3f& >(result))), SWIGTYPE_p_cv__Point3f, SWIG_POINTER_OWN | 0 ); { @@ -9973,22 +10152,22 @@ SWIGINTERN PyObject *_wrap_CameraParameters_getCameraLocation(PyObject *SWIGUNUS } { - if (mat1 != NULL) - delete mat1; + if (arg1 != NULL) + delete arg1; } { - if (mat2 != NULL) - delete mat2; + if (arg2 != NULL) + delete arg2; } return resultobj; fail: { - if (mat1 != NULL) - delete mat1; + if (arg1 != NULL) + delete arg1; } { - if (mat2 != NULL) - delete mat2; + if (arg2 != NULL) + delete arg2; } return NULL; } @@ -10535,6 +10714,27 @@ SWIGINTERN PyObject *_wrap_CameraParameters_getRTMatrix(PyObject *SWIGUNUSEDPARM } +SWIGINTERN PyObject *_wrap_CameraParameters_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_clear" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); + } + arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_CameraParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; @@ -10558,7 +10758,7 @@ SWIGINTERN PyObject *_wrap_delete_CameraParameters(PyObject *SWIGUNUSEDPARM(self SWIGINTERN PyObject *CameraParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__CameraParameters, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -10667,16 +10867,20 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_1(PyObject *SWIGUNUSE cv::Mat *arg1 = 0 ; Marker *arg2 = 0 ; aruco::CameraParameters *arg3 = 0 ; + int arg4 ; uchar *data_ptr1 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; { arg1 = array_to_mat(obj0); if (arg1 == NULL) @@ -10700,7 +10904,12 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); } arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - aruco::CvDrawingUtils::draw3dAxis(*arg1,*arg2,(aruco::CameraParameters const &)*arg3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + aruco::CvDrawingUtils::draw3dAxis(*arg1,*arg2,(aruco::CameraParameters const &)*arg3,arg4); resultobj = SWIG_Py_Void(); { // check if the underlying data changed @@ -10728,16 +10937,82 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat *arg1 = 0 ; + Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + uchar *data_ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2)) SWIG_fail; + { + arg1 = array_to_mat(obj0); + if (arg1 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr1 = arg1->data; + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); + } + arg2 = reinterpret_cast< Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + aruco::CvDrawingUtils::draw3dAxis(*arg1,*arg2,(aruco::CameraParameters const &)*arg3); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr1 != arg1->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg1->rows, arg1->cols, arg1->type()); + SWIG_fail; + } + } + { + if (arg1 != NULL) + delete arg1; + } + return resultobj; +fail: + { + if (arg1 != NULL) + delete arg1; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { @@ -10753,7 +11028,31 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_CvDrawingUtils_draw3dAxis__SWIG_1(self, args); + return _wrap_CvDrawingUtils_draw3dAxis__SWIG_2(self, args); + } + } + } + } + if (argc == 4) { + int _v; + { + _v = is_array(argv[0]) || PySequence_Check(argv[0]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvDrawingUtils_draw3dAxis__SWIG_1(self, args); + } } } } @@ -10792,6 +11091,7 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis(PyObject *self, PyObject *a SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CvDrawingUtils_draw3dAxis'.\n" " Possible C/C++ prototypes are:\n" " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,aruco::CameraParameters const &,cv::Mat const &,cv::Mat const &,float)\n" + " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,Marker &,aruco::CameraParameters const &,int)\n" " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,Marker &,aruco::CameraParameters const &)\n"); return 0; } @@ -10802,13 +11102,97 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_0(PyObject *SWIGUNUSE cv::Mat *arg1 = 0 ; Marker *arg2 = 0 ; aruco::CameraParameters *arg3 = 0 ; - bool arg4 ; + int arg4 ; + bool arg5 ; uchar *data_ptr1 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - bool val4 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvDrawingUtils_draw3dCube",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + { + arg1 = array_to_mat(obj0); + if (arg1 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr1 = arg1->data; + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); + } + arg2 = reinterpret_cast< Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + aruco::CvDrawingUtils::draw3dCube(*arg1,*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr1 != arg1->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg1->rows, arg1->cols, arg1->type()); + SWIG_fail; + } + } + { + if (arg1 != NULL) + delete arg1; + } + return resultobj; +fail: + { + if (arg1 != NULL) + delete arg1; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cv::Mat *arg1 = 0 ; + Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + int arg4 ; + uchar *data_ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; @@ -10839,11 +11223,11 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); } arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); + ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "4"" of type '" "bool""'"); + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "4"" of type '" "int""'"); } - arg4 = static_cast< bool >(val4); + arg4 = static_cast< int >(val4); aruco::CvDrawingUtils::draw3dCube(*arg1,*arg2,(aruco::CameraParameters const &)*arg3,arg4); resultobj = SWIG_Py_Void(); { @@ -10872,7 +11256,7 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; cv::Mat *arg1 = 0 ; Marker *arg2 = 0 ; @@ -10940,14 +11324,14 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_1(PyObject *SWIGUNUSE SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[6] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { + for (ii = 0; (ii < 5) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { @@ -10963,7 +11347,7 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_CvDrawingUtils_draw3dCube__SWIG_1(self, args); + return _wrap_CvDrawingUtils_draw3dCube__SWIG_2(self, args); } } } @@ -10982,11 +11366,41 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube(PyObject *self, PyObject *a _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_bool(argv[3], NULL); + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvDrawingUtils_draw3dCube__SWIG_1(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + { + _v = is_array(argv[0]) || PySequence_Check(argv[0]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_CvDrawingUtils_draw3dCube__SWIG_0(self, args); + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvDrawingUtils_draw3dCube__SWIG_0(self, args); + } } } } @@ -10996,7 +11410,8 @@ SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube(PyObject *self, PyObject *a fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CvDrawingUtils_draw3dCube'.\n" " Possible C/C++ prototypes are:\n" - " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &,bool)\n" + " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &,int,bool)\n" + " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &,int)\n" " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &)\n"); return 0; } @@ -11038,7 +11453,7 @@ SWIGINTERN PyObject *_wrap_delete_CvDrawingUtils(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *CvDrawingUtils_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__CvDrawingUtils, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -11210,7 +11625,7 @@ SWIGINTERN PyObject *_wrap_delete_Debug(PyObject *SWIGUNUSEDPARM(self), PyObject SWIGINTERN PyObject *Debug_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Debug, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -11433,6 +11848,7 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_0(PyObject *SWIGUN bool arg4 ; bool arg5 ; bool arg6 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -11445,15 +11861,18 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_0(PyObject *SWIGUN int ecode5 = 0 ; bool val6 ; int ecode6 = 0 ; + bool val7 ; + int ecode7 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); @@ -11484,7 +11903,12 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dictionary_getMarkerImage_id" "', argument " "6"" of type '" "bool""'"); } arg6 = static_cast< bool >(val6); - result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5,arg6); + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Dictionary_getMarkerImage_id" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5,arg6,arg7); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -11516,6 +11940,7 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_1(PyObject *SWIGUN int arg3 ; bool arg4 ; bool arg5 ; + bool arg6 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -11526,14 +11951,17 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_1(PyObject *SWIGUN int ecode4 = 0 ; bool val5 ; int ecode5 = 0 ; + bool val6 ; + int ecode6 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); @@ -11559,7 +11987,12 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_1(PyObject *SWIGUN SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dictionary_getMarkerImage_id" "', argument " "5"" of type '" "bool""'"); } arg5 = static_cast< bool >(val5); - result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5); + ecode6 = SWIG_AsVal_bool(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dictionary_getMarkerImage_id" "', argument " "6"" of type '" "bool""'"); + } + arg6 = static_cast< bool >(val6); + result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5,arg6); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -11590,6 +12023,7 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_2(PyObject *SWIGUN int arg2 ; int arg3 ; bool arg4 ; + bool arg5 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -11598,13 +12032,16 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_2(PyObject *SWIGUN int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); @@ -11625,11 +12062,16 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_2(PyObject *SWIGUN SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); } arg4 = static_cast< bool >(val4); - result = (arg1)->getMarkerImage_id(arg2,arg3,arg4); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dictionary_getMarkerImage_id" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; // add a reference to the underlying cv::Mat so // that the memory is not freed before the NumPy array @@ -11651,6 +12093,72 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_2(PyObject *SWIGUN SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; + int arg2 ; + int arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); + } + arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + result = (arg1)->getMarkerImage_id(arg2,arg3,arg4); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; int arg2 ; @@ -11709,14 +12217,14 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_3(PyObject *SWIGUN SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[8] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { + for (ii = 0; (ii < 7) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { @@ -11735,7 +12243,7 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_3(self, args); + return _wrap_Dictionary_getMarkerImage_id__SWIG_4(self, args); } } } @@ -11761,7 +12269,7 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_2(self, args); + return _wrap_Dictionary_getMarkerImage_id__SWIG_3(self, args); } } } @@ -11793,7 +12301,7 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_1(self, args); + return _wrap_Dictionary_getMarkerImage_id__SWIG_2(self, args); } } } @@ -11831,7 +12339,52 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_0(self, args); + return _wrap_Dictionary_getMarkerImage_id__SWIG_1(self, args); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Dictionary_getMarkerImage_id__SWIG_0(self, args); + } } } } @@ -11843,6 +12396,7 @@ SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_getMarkerImage_id'.\n" " Possible C/C++ prototypes are:\n" + " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool,bool,bool)\n" " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool,bool)\n" " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool)\n" " aruco::Dictionary::getMarkerImage_id(int,int,bool)\n" @@ -12352,7 +12906,7 @@ SWIGINTERN PyObject *_wrap_delete_Dictionary(PyObject *SWIGUNUSEDPARM(self), PyO SWIGINTERN PyObject *Dictionary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Dictionary, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -14274,7 +14828,7 @@ SWIGINTERN PyObject *_wrap_delete_Point2fVec(PyObject *SWIGUNUSEDPARM(self), PyO SWIGINTERN PyObject *Point2fVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -16190,7 +16744,7 @@ SWIGINTERN PyObject *_wrap_delete_MarkerVec(PyObject *SWIGUNUSEDPARM(self), PyOb SWIGINTERN PyObject *MarkerVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -18106,7 +18660,7 @@ SWIGINTERN PyObject *_wrap_delete_VectorMarker3DInfo(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *VectorMarker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -18434,6 +18988,66 @@ SWIGINTERN PyObject *_wrap_Marker_dict_info_get(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_Marker_contourPoints_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + vector< cv::Point > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker_contourPoints_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_contourPoints_set" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_cv__Point_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_contourPoints_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_contourPoints_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); + } else { + vector< cv::Point > * temp = reinterpret_cast< vector< cv::Point > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->contourPoints = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker_contourPoints_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + vector< cv::Point > result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_contourPoints_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_contourPoints_get" "', argument " "1"" of type '" "aruco::Marker *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = ((arg1)->contourPoints); + resultobj = SWIG_NewPointerObj((new vector< cv::Point >(static_cast< const vector< cv::Point >& >(result))), SWIGTYPE_p_vectorT_cv__Point_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_new_Marker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::Marker *result = 0 ; @@ -19968,1547 +20582,19 @@ SWIGINTERN PyObject *_wrap_Marker_get3DPoints(PyObject *self, PyObject *args) { return _wrap_Marker_get3DPoints__SWIG_0(self, args); } } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_get3DPoints'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Marker::get3DPoints(float)\n" - " aruco::Marker::get3DPoints() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Marker___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Point2f result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker___getitem__" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker___getitem__" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = aruco_Marker___getitem__(arg1,arg2); - { - PyObject* array = point2f_to_array(&result); - if (array == NULL) - SWIG_fail; - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Marker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DM_NORMAL_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *module; - PyObject *d; - if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; - d = PyModule_GetDict(module); - if (!d) return NULL; - SWIG_Python_SetConstant(d, "DM_NORMAL",SWIG_From_int(static_cast< int >(aruco::DM_NORMAL))); - return SWIG_Py_Void(); -} - - -SWIGINTERN PyObject *DM_FAST_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *module; - PyObject *d; - if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; - d = PyModule_GetDict(module); - if (!d) return NULL; - SWIG_Python_SetConstant(d, "DM_FAST",SWIG_From_int(static_cast< int >(aruco::DM_FAST))); - return SWIG_Py_Void(); -} - - -SWIGINTERN PyObject *DM_VIDEO_FAST_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *module; - PyObject *d; - if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; - d = PyModule_GetDict(module); - if (!d) return NULL; - SWIG_Python_SetConstant(d, "DM_VIDEO_FAST",SWIG_From_int(static_cast< int >(aruco::DM_VIDEO_FAST))); - return SWIG_Py_Void(); -} - - -SWIGINTERN PyObject *THRES_ADAPTIVE_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *module; - PyObject *d; - if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; - d = PyModule_GetDict(module); - if (!d) return NULL; - SWIG_Python_SetConstant(d, "THRES_ADAPTIVE",SWIG_From_int(static_cast< int >(aruco::THRES_ADAPTIVE))); - return SWIG_Py_Void(); -} - - -SWIGINTERN PyObject *THRES_AUTO_FIXED_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *module; - PyObject *d; - if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL; - d = PyModule_GetDict(module); - if (!d) return NULL; - SWIG_Python_SetConstant(d, "THRES_AUTO_FIXED",SWIG_From_int(static_cast< int >(aruco::THRES_AUTO_FIXED))); - return SWIG_Py_Void(); -} - - -SWIGINTERN PyObject *_wrap_Params_maxThreads_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_maxThreads_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_maxThreads_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_maxThreads_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->maxThreads = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_maxThreads_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_maxThreads_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_maxThreads_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->maxThreads); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_borderDistThres_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_borderDistThres_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_borderDistThres_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_borderDistThres_set" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - if (arg1) (arg1)->borderDistThres = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_borderDistThres_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_borderDistThres_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_borderDistThres_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (float) ((arg1)->borderDistThres); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_lowResMarkerSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_lowResMarkerSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_lowResMarkerSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_lowResMarkerSize_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->lowResMarkerSize = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_lowResMarkerSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_lowResMarkerSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_lowResMarkerSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->lowResMarkerSize); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_minSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_minSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_minSize_set" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - if (arg1) (arg1)->minSize = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_minSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_minSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (float) ((arg1)->minSize); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_minSize_pix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_minSize_pix_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_pix_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_minSize_pix_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->minSize_pix = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_minSize_pix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_minSize_pix_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_minSize_pix_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->minSize_pix); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_enclosedMarker_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_enclosedMarker_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_enclosedMarker_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_enclosedMarker_set" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - if (arg1) (arg1)->enclosedMarker = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_enclosedMarker_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_enclosedMarker_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_enclosedMarker_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (bool) ((arg1)->enclosedMarker); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - aruco::ThresMethod arg2 ; - int arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - int val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Params_setThresholdMethod",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); - } - arg2 = static_cast< aruco::ThresMethod >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setThresholdMethod" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Params_setThresholdMethod" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_int(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Params_setThresholdMethod" "', argument " "5"" of type '" "int""'"); - } - arg5 = static_cast< int >(val5); - (arg1)->setThresholdMethod(arg2,arg3,arg4,arg5); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - aruco::ThresMethod arg2 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:Params_setThresholdMethod",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); - } - arg2 = static_cast< aruco::ThresMethod >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setThresholdMethod" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Params_setThresholdMethod" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - (arg1)->setThresholdMethod(arg2,arg3,arg4); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - aruco::ThresMethod arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Params_setThresholdMethod",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); - } - arg2 = static_cast< aruco::ThresMethod >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setThresholdMethod" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - (arg1)->setThresholdMethod(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setThresholdMethod__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - aruco::ThresMethod arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_setThresholdMethod",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setThresholdMethod" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setThresholdMethod" "', argument " "2"" of type '" "aruco::ThresMethod""'"); - } - arg2 = static_cast< aruco::ThresMethod >(val2); - (arg1)->setThresholdMethod(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setThresholdMethod(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Params_setThresholdMethod__SWIG_3(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Params_setThresholdMethod__SWIG_2(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Params_setThresholdMethod__SWIG_1(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Params_setThresholdMethod__SWIG_0(self, args); - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Params_setThresholdMethod'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Params::setThresholdMethod(aruco::ThresMethod,int,int,int)\n" - " aruco::Params::setThresholdMethod(aruco::ThresMethod,int,int)\n" - " aruco::Params::setThresholdMethod(aruco::ThresMethod,int)\n" - " aruco::Params::setThresholdMethod(aruco::ThresMethod)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Params__thresMethod_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - aruco::ThresMethod arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params__thresMethod_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__thresMethod_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__thresMethod_set" "', argument " "2"" of type '" "aruco::ThresMethod""'"); - } - arg2 = static_cast< aruco::ThresMethod >(val2); - if (arg1) (arg1)->_thresMethod = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__thresMethod_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::ThresMethod result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params__thresMethod_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__thresMethod_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (aruco::ThresMethod) ((arg1)->_thresMethod); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_NAttemptsAutoThresFix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_NAttemptsAutoThresFix_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_NAttemptsAutoThresFix_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_NAttemptsAutoThresFix_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->NAttemptsAutoThresFix = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_NAttemptsAutoThresFix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_NAttemptsAutoThresFix_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_NAttemptsAutoThresFix_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->NAttemptsAutoThresFix); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params__AdaptiveThresWindowSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__AdaptiveThresWindowSize_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->_AdaptiveThresWindowSize = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params__AdaptiveThresWindowSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->_AdaptiveThresWindowSize); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__ThresHold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params__ThresHold_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ThresHold_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__ThresHold_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->_ThresHold = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__ThresHold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params__ThresHold_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ThresHold_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->_ThresHold); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_range_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params__AdaptiveThresWindowSize_range_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_range_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__AdaptiveThresWindowSize_range_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->_AdaptiveThresWindowSize_range = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__AdaptiveThresWindowSize_range_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params__AdaptiveThresWindowSize_range_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__AdaptiveThresWindowSize_range_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->_AdaptiveThresWindowSize_range); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__markerWarpPixSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params__markerWarpPixSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__markerWarpPixSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__markerWarpPixSize_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->_markerWarpPixSize = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__markerWarpPixSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params__markerWarpPixSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__markerWarpPixSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (int) ((arg1)->_markerWarpPixSize); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__autoSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params__autoSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__autoSize_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__autoSize_set" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - if (arg1) (arg1)->_autoSize = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__autoSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params__autoSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__autoSize_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (bool) ((arg1)->_autoSize); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__ts_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params__ts_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ts_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params__ts_set" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - if (arg1) (arg1)->_ts = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params__ts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params__ts_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params__ts_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (float) ((arg1)->_ts); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setAutoSizeSpeedUp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - bool arg2 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Params_setAutoSizeSpeedUp",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setAutoSizeSpeedUp(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setAutoSizeSpeedUp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_setAutoSizeSpeedUp",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_setAutoSizeSpeedUp" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - (arg1)->setAutoSizeSpeedUp(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_setAutoSizeSpeedUp(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Params_setAutoSizeSpeedUp__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Params, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Params_setAutoSizeSpeedUp__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Params_setAutoSizeSpeedUp'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Params::setAutoSizeSpeedUp(bool,float)\n" - " aruco::Params::setAutoSizeSpeedUp(bool)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Params_getAutoSizeSpeedUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_getAutoSizeSpeedUp",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_getAutoSizeSpeedUp" "', argument " "1"" of type '" "aruco::Params const *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (bool)((aruco::Params const *)arg1)->getAutoSizeSpeedUp(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_pyrfactor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Params_pyrfactor_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_pyrfactor_set" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Params_pyrfactor_set" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - if (arg1) (arg1)->pyrfactor = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Params_pyrfactor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Params_pyrfactor_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Params_pyrfactor_get" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - result = (float) ((arg1)->pyrfactor); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Params")) SWIG_fail; - result = (aruco::Params *)new aruco::Params(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Params, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_Params(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Params *arg1 = (aruco::Params *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_Params",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Params, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Params" "', argument " "1"" of type '" "aruco::Params *""'"); - } - arg1 = reinterpret_cast< aruco::Params * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Params_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Params, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_MarkerCandidate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerCandidate *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_MarkerCandidate")) SWIG_fail; - result = (aruco::MarkerCandidate *)new aruco::MarkerCandidate(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerCandidate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::MarkerCandidate *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerCandidate",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::Marker const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::Marker const &""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (aruco::MarkerCandidate *)new aruco::MarkerCandidate((aruco::Marker const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerCandidate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerCandidate *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::MarkerCandidate *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerCandidate",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::MarkerCandidate const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerCandidate" "', argument " "1"" of type '" "aruco::MarkerCandidate const &""'"); - } - arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); - result = (aruco::MarkerCandidate *)new aruco::MarkerCandidate((aruco::MarkerCandidate const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerCandidate(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_MarkerCandidate__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__MarkerCandidate, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MarkerCandidate__SWIG_2(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MarkerCandidate__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerCandidate'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerCandidate::MarkerCandidate()\n" - " aruco::MarkerCandidate::MarkerCandidate(aruco::Marker const &)\n" - " aruco::MarkerCandidate::MarkerCandidate(aruco::MarkerCandidate const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerCandidate_contour_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; - vector< cv::Point > arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerCandidate_contour_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_contour_set" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_cv__Point_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerCandidate_contour_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerCandidate_contour_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); - } else { - vector< cv::Point > * temp = reinterpret_cast< vector< cv::Point > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->contour = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerCandidate_contour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - vector< cv::Point > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerCandidate_contour_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_contour_get" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); - result = ((arg1)->contour); - resultobj = SWIG_NewPointerObj((new vector< cv::Point >(static_cast< const vector< cv::Point >& >(result))), SWIGTYPE_p_vectorT_cv__Point_t, SWIG_POINTER_OWN | 0 ); - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_get3DPoints'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Marker::get3DPoints(float)\n" + " aruco::Marker::get3DPoints() const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MarkerCandidate_idx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Marker___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21516,73 +20602,37 @@ SWIGINTERN PyObject *_wrap_MarkerCandidate_idx_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + cv::Point2f result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerCandidate_idx_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:Marker___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_idx_set" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker___getitem__" "', argument " "1"" of type '" "aruco::Marker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); + arg1 = reinterpret_cast< aruco::Marker * >(argp1); ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerCandidate_idx_set" "', argument " "2"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker___getitem__" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - if (arg1) (arg1)->idx = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerCandidate_idx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerCandidate_idx_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerCandidate_idx_get" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); - result = (int) ((arg1)->idx); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MarkerCandidate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerCandidate *arg1 = (aruco::MarkerCandidate *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerCandidate",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerCandidate, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerCandidate" "', argument " "1"" of type '" "aruco::MarkerCandidate *""'"); + result = aruco_Marker___getitem__(arg1,arg2); + { + PyObject* array = point2f_to_array(&result); + if (array == NULL) + SWIG_fail; + + resultobj = array; } - arg1 = reinterpret_cast< aruco::MarkerCandidate * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MarkerCandidate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *Marker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerCandidate, SWIG_NewClientData(obj)); + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -21785,6 +20835,80 @@ SWIGINTERN PyObject *_wrap_new_MarkerDetector(PyObject *self, PyObject *args) { } +SWIGINTERN PyObject *_wrap_MarkerDetector_saveParamsToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_saveParamsToFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_saveParamsToFile" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_saveParamsToFile" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_saveParamsToFile" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + ((aruco::MarkerDetector const *)arg1)->saveParamsToFile((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_loadParamsFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_loadParamsFromFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_loadParamsFromFile" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_loadParamsFromFile" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_loadParamsFromFile" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->loadParamsFromFile((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_MarkerDetector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; @@ -23119,7 +22243,7 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_0(PyObject *SWIGUN void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - aruco::Params result; + aruco::MarkerDetector::Params result; if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); @@ -23128,7 +22252,7 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_0(PyObject *SWIGUN } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); result = ((aruco::MarkerDetector const *)arg1)->getParameters(); - resultobj = SWIG_NewPointerObj((new aruco::Params(static_cast< const aruco::Params& >(result))), SWIGTYPE_p_aruco__Params, SWIG_POINTER_OWN | 0 ); + resultobj = SWIG_NewPointerObj((new aruco::MarkerDetector::Params(static_cast< const aruco::MarkerDetector::Params& >(result))), SWIGTYPE_p_aruco__MarkerDetector__Params, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; @@ -23141,7 +22265,7 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_1(PyObject *SWIGUN void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - aruco::Params *result = 0 ; + aruco::MarkerDetector::Params *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); @@ -23149,8 +22273,8 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_1(PyObject *SWIGUN SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (aruco::Params *) &(arg1)->getParameters(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Params, 0 | 0 ); + result = (aruco::MarkerDetector::Params *) &(arg1)->getParameters(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0 ); return resultobj; fail: return NULL; @@ -23570,6 +22694,28 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage(PyObject *self, Py } +SWIGINTERN PyObject *_wrap_MarkerDetector_getNhresholdedImages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + size_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getNhresholdedImages",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getNhresholdedImages" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = ((aruco::MarkerDetector const *)arg1)->getNhresholdedImages(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_MarkerDetector_setMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; @@ -23752,9 +22898,108 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_warp(PyObject *SWIGUNUSEDPARM(self), P } +SWIGINTERN PyObject *_wrap_MarkerDetector_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_toStream" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + ((aruco::MarkerDetector const *)arg1)->toStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_fromStream" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + (arg1)->fromStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::MarkerDetector::Params *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setParameters",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); + } + arg2 = reinterpret_cast< aruco::MarkerDetector::Params * >(argp2); + (arg1)->setParameters((aruco::MarkerDetector::Params const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *MarkerDetector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerDetector, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -24106,7 +23351,7 @@ SWIGINTERN PyObject *_wrap_delete_MarkerLabeler(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *MarkerLabeler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerLabeler, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -24516,7 +23761,7 @@ SWIGINTERN PyObject *_wrap_delete_Marker3DInfo(PyObject *SWIGUNUSEDPARM(self), P SWIGINTERN PyObject *Marker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker3DInfo, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -24650,7 +23895,7 @@ SWIGINTERN PyObject *_wrap_MarkerMap_convertToMeters(PyObject *SWIGUNUSEDPARM(se if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_convertToMeters",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_convertToMeters" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_convertToMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); } arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); ecode2 = SWIG_AsVal_float(obj1, &val2); @@ -24658,7 +23903,7 @@ SWIGINTERN PyObject *_wrap_MarkerMap_convertToMeters(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_convertToMeters" "', argument " "2"" of type '" "float""'"); } arg2 = static_cast< float >(val2); - result = (arg1)->convertToMeters(arg2); + result = ((aruco::MarkerMap const *)arg1)->convertToMeters(arg2); resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); return resultobj; fail: @@ -25372,7 +24617,7 @@ SWIGINTERN PyObject *_wrap_delete_MarkerMap(PyObject *SWIGUNUSEDPARM(self), PyOb SWIGINTERN PyObject *MarkerMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMap, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -25725,7 +24970,7 @@ SWIGINTERN PyObject *_wrap_delete_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *MarkerPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -26102,6 +25347,45 @@ SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM } +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setMaxTrackingDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + float arg2 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setMaxTrackingDifference",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setMaxTrackingDifference(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; @@ -26125,7 +25409,7 @@ SWIGINTERN PyObject *_wrap_delete_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM( SWIGINTERN PyObject *MarkerMapPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -26328,7 +25612,7 @@ SWIGINTERN PyObject *_wrap_new_DictionaryBased(PyObject *SWIGUNUSEDPARM(self), P SWIGINTERN PyObject *DictionaryBased_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__DictionaryBased, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -26588,7 +25872,7 @@ SWIGINTERN PyObject *_wrap_SVMMarkers_getBestInputSize(PyObject *SWIGUNUSEDPARM( SWIGINTERN PyObject *SVMMarkers_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__SVMMarkers, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -27063,7 +26347,7 @@ SWIGINTERN PyObject *_wrap_delete_ScopeTimer(PyObject *SWIGUNUSEDPARM(self), PyO SWIGINTERN PyObject *ScopeTimer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__ScopeTimer, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -27552,7 +26836,7 @@ SWIGINTERN PyObject *_wrap_delete_ScopedTimerEvents(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *ScopedTimerEvents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -28143,7 +27427,7 @@ SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Timer, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -28202,8 +27486,6 @@ static PyMethodDef SwigMethods[] = { { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL}, { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL}, { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL}, - { (char *)"ARUCO_VERSION_MAJOR_swigconstant", ARUCO_VERSION_MAJOR_swigconstant, METH_VARARGS, NULL}, - { (char *)"ARUCO_VERSION_MINOR_swigconstant", ARUCO_VERSION_MINOR_swigconstant, METH_VARARGS, NULL}, { (char *)"CameraParameters_CameraMatrix_set", _wrap_CameraParameters_CameraMatrix_set, METH_VARARGS, NULL}, { (char *)"CameraParameters_CameraMatrix_get", _wrap_CameraParameters_CameraMatrix_get, METH_VARARGS, NULL}, { (char *)"CameraParameters_Distorsion_set", _wrap_CameraParameters_Distorsion_set, METH_VARARGS, NULL}, @@ -28220,6 +27502,7 @@ static PyMethodDef SwigMethods[] = { { (char *)"CameraParameters_glGetProjectionMatrix", _wrap_CameraParameters_glGetProjectionMatrix, METH_VARARGS, NULL}, { (char *)"CameraParameters_OgreGetProjectionMatrix", _wrap_CameraParameters_OgreGetProjectionMatrix, METH_VARARGS, NULL}, { (char *)"CameraParameters_getRTMatrix", _wrap_CameraParameters_getRTMatrix, METH_VARARGS, NULL}, + { (char *)"CameraParameters_clear", _wrap_CameraParameters_clear, METH_VARARGS, NULL}, { (char *)"delete_CameraParameters", _wrap_delete_CameraParameters, METH_VARARGS, NULL}, { (char *)"CameraParameters_swigregister", CameraParameters_swigregister, METH_VARARGS, NULL}, { (char *)"CvDrawingUtils_draw3dAxis", _wrap_CvDrawingUtils_draw3dAxis, METH_VARARGS, NULL}, @@ -28369,6 +27652,8 @@ static PyMethodDef SwigMethods[] = { { (char *)"Marker_Tvec_get", _wrap_Marker_Tvec_get, METH_VARARGS, NULL}, { (char *)"Marker_dict_info_set", _wrap_Marker_dict_info_set, METH_VARARGS, NULL}, { (char *)"Marker_dict_info_get", _wrap_Marker_dict_info_get, METH_VARARGS, NULL}, + { (char *)"Marker_contourPoints_set", _wrap_Marker_contourPoints_set, METH_VARARGS, NULL}, + { (char *)"Marker_contourPoints_get", _wrap_Marker_contourPoints_get, METH_VARARGS, NULL}, { (char *)"new_Marker", _wrap_new_Marker, METH_VARARGS, NULL}, { (char *)"delete_Marker", _wrap_delete_Marker, METH_VARARGS, NULL}, { (char *)"Marker_isValid", _wrap_Marker_isValid, METH_VARARGS, NULL}, @@ -28387,55 +27672,9 @@ static PyMethodDef SwigMethods[] = { { (char *)"Marker_get3DPoints", _wrap_Marker_get3DPoints, METH_VARARGS, NULL}, { (char *)"Marker___getitem__", _wrap_Marker___getitem__, METH_VARARGS, NULL}, { (char *)"Marker_swigregister", Marker_swigregister, METH_VARARGS, NULL}, - { (char *)"DM_NORMAL_swigconstant", DM_NORMAL_swigconstant, METH_VARARGS, NULL}, - { (char *)"DM_FAST_swigconstant", DM_FAST_swigconstant, METH_VARARGS, NULL}, - { (char *)"DM_VIDEO_FAST_swigconstant", DM_VIDEO_FAST_swigconstant, METH_VARARGS, NULL}, - { (char *)"THRES_ADAPTIVE_swigconstant", THRES_ADAPTIVE_swigconstant, METH_VARARGS, NULL}, - { (char *)"THRES_AUTO_FIXED_swigconstant", THRES_AUTO_FIXED_swigconstant, METH_VARARGS, NULL}, - { (char *)"Params_maxThreads_set", _wrap_Params_maxThreads_set, METH_VARARGS, NULL}, - { (char *)"Params_maxThreads_get", _wrap_Params_maxThreads_get, METH_VARARGS, NULL}, - { (char *)"Params_borderDistThres_set", _wrap_Params_borderDistThres_set, METH_VARARGS, NULL}, - { (char *)"Params_borderDistThres_get", _wrap_Params_borderDistThres_get, METH_VARARGS, NULL}, - { (char *)"Params_lowResMarkerSize_set", _wrap_Params_lowResMarkerSize_set, METH_VARARGS, NULL}, - { (char *)"Params_lowResMarkerSize_get", _wrap_Params_lowResMarkerSize_get, METH_VARARGS, NULL}, - { (char *)"Params_minSize_set", _wrap_Params_minSize_set, METH_VARARGS, NULL}, - { (char *)"Params_minSize_get", _wrap_Params_minSize_get, METH_VARARGS, NULL}, - { (char *)"Params_minSize_pix_set", _wrap_Params_minSize_pix_set, METH_VARARGS, NULL}, - { (char *)"Params_minSize_pix_get", _wrap_Params_minSize_pix_get, METH_VARARGS, NULL}, - { (char *)"Params_enclosedMarker_set", _wrap_Params_enclosedMarker_set, METH_VARARGS, NULL}, - { (char *)"Params_enclosedMarker_get", _wrap_Params_enclosedMarker_get, METH_VARARGS, NULL}, - { (char *)"Params_setThresholdMethod", _wrap_Params_setThresholdMethod, METH_VARARGS, NULL}, - { (char *)"Params__thresMethod_set", _wrap_Params__thresMethod_set, METH_VARARGS, NULL}, - { (char *)"Params__thresMethod_get", _wrap_Params__thresMethod_get, METH_VARARGS, NULL}, - { (char *)"Params_NAttemptsAutoThresFix_set", _wrap_Params_NAttemptsAutoThresFix_set, METH_VARARGS, NULL}, - { (char *)"Params_NAttemptsAutoThresFix_get", _wrap_Params_NAttemptsAutoThresFix_get, METH_VARARGS, NULL}, - { (char *)"Params__AdaptiveThresWindowSize_set", _wrap_Params__AdaptiveThresWindowSize_set, METH_VARARGS, NULL}, - { (char *)"Params__AdaptiveThresWindowSize_get", _wrap_Params__AdaptiveThresWindowSize_get, METH_VARARGS, NULL}, - { (char *)"Params__ThresHold_set", _wrap_Params__ThresHold_set, METH_VARARGS, NULL}, - { (char *)"Params__ThresHold_get", _wrap_Params__ThresHold_get, METH_VARARGS, NULL}, - { (char *)"Params__AdaptiveThresWindowSize_range_set", _wrap_Params__AdaptiveThresWindowSize_range_set, METH_VARARGS, NULL}, - { (char *)"Params__AdaptiveThresWindowSize_range_get", _wrap_Params__AdaptiveThresWindowSize_range_get, METH_VARARGS, NULL}, - { (char *)"Params__markerWarpPixSize_set", _wrap_Params__markerWarpPixSize_set, METH_VARARGS, NULL}, - { (char *)"Params__markerWarpPixSize_get", _wrap_Params__markerWarpPixSize_get, METH_VARARGS, NULL}, - { (char *)"Params__autoSize_set", _wrap_Params__autoSize_set, METH_VARARGS, NULL}, - { (char *)"Params__autoSize_get", _wrap_Params__autoSize_get, METH_VARARGS, NULL}, - { (char *)"Params__ts_set", _wrap_Params__ts_set, METH_VARARGS, NULL}, - { (char *)"Params__ts_get", _wrap_Params__ts_get, METH_VARARGS, NULL}, - { (char *)"Params_setAutoSizeSpeedUp", _wrap_Params_setAutoSizeSpeedUp, METH_VARARGS, NULL}, - { (char *)"Params_getAutoSizeSpeedUp", _wrap_Params_getAutoSizeSpeedUp, METH_VARARGS, NULL}, - { (char *)"Params_pyrfactor_set", _wrap_Params_pyrfactor_set, METH_VARARGS, NULL}, - { (char *)"Params_pyrfactor_get", _wrap_Params_pyrfactor_get, METH_VARARGS, NULL}, - { (char *)"new_Params", _wrap_new_Params, METH_VARARGS, NULL}, - { (char *)"delete_Params", _wrap_delete_Params, METH_VARARGS, NULL}, - { (char *)"Params_swigregister", Params_swigregister, METH_VARARGS, NULL}, - { (char *)"new_MarkerCandidate", _wrap_new_MarkerCandidate, METH_VARARGS, NULL}, - { (char *)"MarkerCandidate_contour_set", _wrap_MarkerCandidate_contour_set, METH_VARARGS, NULL}, - { (char *)"MarkerCandidate_contour_get", _wrap_MarkerCandidate_contour_get, METH_VARARGS, NULL}, - { (char *)"MarkerCandidate_idx_set", _wrap_MarkerCandidate_idx_set, METH_VARARGS, NULL}, - { (char *)"MarkerCandidate_idx_get", _wrap_MarkerCandidate_idx_get, METH_VARARGS, NULL}, - { (char *)"delete_MarkerCandidate", _wrap_delete_MarkerCandidate, METH_VARARGS, NULL}, - { (char *)"MarkerCandidate_swigregister", MarkerCandidate_swigregister, METH_VARARGS, NULL}, { (char *)"new_MarkerDetector", _wrap_new_MarkerDetector, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_saveParamsToFile", _wrap_MarkerDetector_saveParamsToFile, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_loadParamsFromFile", _wrap_MarkerDetector_loadParamsFromFile, METH_VARARGS, NULL}, { (char *)"delete_MarkerDetector", _wrap_delete_MarkerDetector, METH_VARARGS, NULL}, { (char *)"MarkerDetector_setDetectionMode", _wrap_MarkerDetector_setDetectionMode, METH_VARARGS, NULL}, { (char *)"MarkerDetector_getDetectionMode", _wrap_MarkerDetector_getDetectionMode, METH_VARARGS, NULL}, @@ -28443,10 +27682,14 @@ static PyMethodDef SwigMethods[] = { { (char *)"MarkerDetector_getParameters", _wrap_MarkerDetector_getParameters, METH_VARARGS, NULL}, { (char *)"MarkerDetector_setDictionary", _wrap_MarkerDetector_setDictionary, METH_VARARGS, NULL}, { (char *)"MarkerDetector_getThresholdedImage", _wrap_MarkerDetector_getThresholdedImage, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_getNhresholdedImages", _wrap_MarkerDetector_getNhresholdedImages, METH_VARARGS, NULL}, { (char *)"MarkerDetector_setMarkerLabeler", _wrap_MarkerDetector_setMarkerLabeler, METH_VARARGS, NULL}, { (char *)"MarkerDetector_getMarkerLabeler", _wrap_MarkerDetector_getMarkerLabeler, METH_VARARGS, NULL}, { (char *)"MarkerDetector_getCandidates", _wrap_MarkerDetector_getCandidates, METH_VARARGS, NULL}, { (char *)"MarkerDetector_warp", _wrap_MarkerDetector_warp, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_toStream", _wrap_MarkerDetector_toStream, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_fromStream", _wrap_MarkerDetector_fromStream, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_setParameters", _wrap_MarkerDetector_setParameters, METH_VARARGS, NULL}, { (char *)"MarkerDetector_swigregister", MarkerDetector_swigregister, METH_VARARGS, NULL}, { (char *)"MarkerLabeler_create", _wrap_MarkerLabeler_create, METH_VARARGS, NULL}, { (char *)"MarkerLabeler_detect", _wrap_MarkerLabeler_detect, METH_VARARGS, NULL}, @@ -28504,6 +27747,7 @@ static PyMethodDef SwigMethods[] = { { (char *)"MarkerMapPoseTracker_getRTMatrix", _wrap_MarkerMapPoseTracker_getRTMatrix, METH_VARARGS, NULL}, { (char *)"MarkerMapPoseTracker_getRvec", _wrap_MarkerMapPoseTracker_getRvec, METH_VARARGS, NULL}, { (char *)"MarkerMapPoseTracker_getTvec", _wrap_MarkerMapPoseTracker_getTvec, METH_VARARGS, NULL}, + { (char *)"MarkerMapPoseTracker_setMaxTrackingDifference", _wrap_MarkerMapPoseTracker_setMaxTrackingDifference, METH_VARARGS, NULL}, { (char *)"delete_MarkerMapPoseTracker", _wrap_delete_MarkerMapPoseTracker, METH_VARARGS, NULL}, { (char *)"MarkerMapPoseTracker_swigregister", MarkerMapPoseTracker_swigregister, METH_VARARGS, NULL}, { (char *)"delete_DictionaryBased", _wrap_delete_DictionaryBased, METH_VARARGS, NULL}, @@ -28568,15 +27812,9 @@ static PyMethodDef SwigMethods[] = { /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_aruco__MarkerCandidateTo_p_aruco__Marker(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((aruco::Marker *) ((aruco::MarkerCandidate *) x)); -} static void *_p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((std::vector< cv::Point2f,std::allocator< cv::Point2f > > *) ((aruco::Marker *) x)); } -static void *_p_aruco__MarkerCandidateTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((std::vector< cv::Point2f,std::allocator< cv::Point2f > > *) (aruco::Marker *) ((aruco::MarkerCandidate *) x)); -} static void *_p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *) ((aruco::MarkerMap *) x)); } @@ -28595,13 +27833,12 @@ static swig_type_info _swigt__p_aruco__Dictionary = {"_p_aruco__Dictionary", "ar static swig_type_info _swigt__p_aruco__DictionaryBased = {"_p_aruco__DictionaryBased", "aruco::DictionaryBased *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__Marker = {"_p_aruco__Marker", "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *|aruco::Marker *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__Marker3DInfo = {"_p_aruco__Marker3DInfo", "aruco::Marker3DInfo *|std::vector< aruco::Marker3DInfo >::value_type *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__MarkerCandidate = {"_p_aruco__MarkerCandidate", "aruco::MarkerCandidate *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerDetector = {"_p_aruco__MarkerDetector", "aruco::MarkerDetector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__MarkerDetector__Params = {"_p_aruco__MarkerDetector__Params", "aruco::MarkerDetector::Params *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerLabeler = {"_p_aruco__MarkerLabeler", "aruco::MarkerLabeler *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerMap = {"_p_aruco__MarkerMap", "aruco::MarkerMap *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerMapPoseTracker = {"_p_aruco__MarkerMapPoseTracker", "aruco::MarkerMapPoseTracker *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerPoseTracker = {"_p_aruco__MarkerPoseTracker", "aruco::MarkerPoseTracker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__Params = {"_p_aruco__Params", "aruco::Params *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__SVMMarkers = {"_p_aruco__SVMMarkers", "aruco::SVMMarkers *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__ScopeTimer = {"_p_aruco__ScopeTimer", "aruco::ScopeTimer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__ScopedTimerEvents = {"_p_aruco__ScopedTimerEvents", "aruco::ScopedTimerEvents *", 0, 0, (void*)0, 0}; @@ -28654,13 +27891,12 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_aruco__DictionaryBased, &_swigt__p_aruco__Marker, &_swigt__p_aruco__Marker3DInfo, - &_swigt__p_aruco__MarkerCandidate, &_swigt__p_aruco__MarkerDetector, + &_swigt__p_aruco__MarkerDetector__Params, &_swigt__p_aruco__MarkerLabeler, &_swigt__p_aruco__MarkerMap, &_swigt__p_aruco__MarkerMapPoseTracker, &_swigt__p_aruco__MarkerPoseTracker, - &_swigt__p_aruco__Params, &_swigt__p_aruco__SVMMarkers, &_swigt__p_aruco__ScopeTimer, &_swigt__p_aruco__ScopedTimerEvents, @@ -28711,15 +27947,14 @@ static swig_cast_info _swigc__p_aruco__CvDrawingUtils[] = { {&_swigt__p_aruco__ static swig_cast_info _swigc__p_aruco__Debug[] = { {&_swigt__p_aruco__Debug, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__Dictionary[] = { {&_swigt__p_aruco__Dictionary, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__DictionaryBased[] = { {&_swigt__p_aruco__DictionaryBased, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Marker[] = { {&_swigt__p_aruco__MarkerCandidate, _p_aruco__MarkerCandidateTo_p_aruco__Marker, 0, 0}, {&_swigt__p_aruco__Marker, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Marker[] = { {&_swigt__p_aruco__Marker, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__Marker3DInfo[] = { {&_swigt__p_aruco__Marker3DInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerCandidate[] = { {&_swigt__p_aruco__MarkerCandidate, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerDetector[] = { {&_swigt__p_aruco__MarkerDetector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerDetector__Params[] = { {&_swigt__p_aruco__MarkerDetector__Params, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerLabeler[] = { {&_swigt__p_aruco__SVMMarkers, _p_aruco__SVMMarkersTo_p_aruco__MarkerLabeler, 0, 0}, {&_swigt__p_aruco__MarkerLabeler, 0, 0, 0}, {&_swigt__p_aruco__DictionaryBased, _p_aruco__DictionaryBasedTo_p_aruco__MarkerLabeler, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerMap[] = { {&_swigt__p_aruco__MarkerMap, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerMapPoseTracker[] = { {&_swigt__p_aruco__MarkerMapPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerPoseTracker[] = { {&_swigt__p_aruco__MarkerPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Params[] = { {&_swigt__p_aruco__Params, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__SVMMarkers[] = { {&_swigt__p_aruco__SVMMarkers, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__ScopeTimer[] = { {&_swigt__p_aruco__ScopeTimer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__ScopedTimerEvents[] = { {&_swigt__p_aruco__ScopedTimerEvents, 0, 0, 0},{0, 0, 0, 0}}; @@ -28747,7 +27982,7 @@ static swig_cast_info _swigc__p_std__pairT_cv__Mat_cv__Mat_t[] = { {&_swigt__p_ static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0, 0}, {&_swigt__p_aruco__MarkerMap, _p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t[] = { {&_swigt__p_aruco__MarkerCandidate, _p_aruco__MarkerCandidateTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0}, {&_swigt__p_aruco__Marker, _p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0}, {&_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t[] = { {&_swigt__p_aruco__Marker, _p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0}, {&_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t[] = { {&_swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t[] = { {&_swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -28772,13 +28007,12 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_aruco__DictionaryBased, _swigc__p_aruco__Marker, _swigc__p_aruco__Marker3DInfo, - _swigc__p_aruco__MarkerCandidate, _swigc__p_aruco__MarkerDetector, + _swigc__p_aruco__MarkerDetector__Params, _swigc__p_aruco__MarkerLabeler, _swigc__p_aruco__MarkerMap, _swigc__p_aruco__MarkerMapPoseTracker, _swigc__p_aruco__MarkerPoseTracker, - _swigc__p_aruco__Params, _swigc__p_aruco__SVMMarkers, _swigc__p_aruco__ScopeTimer, _swigc__p_aruco__ScopedTimerEvents, @@ -29199,7 +28433,6 @@ extern "C" { static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { - /* PyObject header changed in Python 3 */ #if PY_VERSION_HEX >= 0x03000000 PyVarObject_HEAD_INIT(NULL, 0) #else @@ -29431,13 +28664,13 @@ SWIG_init(void) { static PyGetSetDef thisown_getset_def = { (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure }; - PyObject *metatype_args; PyTypeObject *builtin_pytype; int builtin_base_count; swig_type_info *builtin_basetype; PyObject *tuple; PyGetSetDescrObject *static_getset; PyTypeObject *metatype; + PyTypeObject *swigpyobject; SwigPyClientData *cd; PyObject *public_interface, *public_symbol; PyObject *this_descr; @@ -29452,14 +28685,9 @@ SWIG_init(void) { (void)static_getset; (void)self; - /* metatype is used to implement static member variables. */ - metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type); - assert(metatype_args); - metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL); + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); assert(metatype); - Py_DECREF(metatype_args); - metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro; - assert(PyType_Ready(metatype) >= 0); #endif /* Fix SwigMethods to carry the callback ptrs when needed */ @@ -29477,13 +28705,15 @@ SWIG_init(void) { SWIG_InitializeModule(0); #ifdef SWIGPYTHON_BUILTIN + swigpyobject = SwigPyObject_TypeOnce(); + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); assert(SwigPyObject_stype); cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; if (!cd) { SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; - SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce(); - } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) { + SwigPyObject_clientdata.pytype = swigpyobject; + } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); # if PY_VERSION_HEX >= 0x03000000 return NULL; @@ -29517,6 +28747,9 @@ SWIG_init(void) { import_array(); + SWIG_Python_SetConstant(d, "ARUCO_VERSION_MAJOR",SWIG_From_int(static_cast< int >(3))); + SWIG_Python_SetConstant(d, "ARUCO_VERSION_MINOR",SWIG_From_int(static_cast< int >(0))); + SWIG_Python_SetConstant(d, "Dictionary_ALL_DICTS",SWIG_From_int(static_cast< int >(aruco::Dictionary::ALL_DICTS))); SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_36h12",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_36h12))); SWIG_Python_SetConstant(d, "Dictionary_ARUCO",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO))); SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_25h7",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_25h7))); @@ -29531,7 +28764,12 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Dictionary_TAG36h10",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG36h10))); SWIG_Python_SetConstant(d, "Dictionary_CHILITAGS",SWIG_From_int(static_cast< int >(aruco::Dictionary::CHILITAGS))); SWIG_Python_SetConstant(d, "Dictionary_CUSTOM",SWIG_From_int(static_cast< int >(aruco::Dictionary::CUSTOM))); - SWIG_Python_SetConstant(d, "Dictionary_ALL_DICTS",SWIG_From_int(static_cast< int >(aruco::Dictionary::ALL_DICTS))); + SWIG_Python_SetConstant(d, "DM_NORMAL",SWIG_From_int(static_cast< int >(aruco::DM_NORMAL))); + SWIG_Python_SetConstant(d, "DM_FAST",SWIG_From_int(static_cast< int >(aruco::DM_FAST))); + SWIG_Python_SetConstant(d, "DM_VIDEO_FAST",SWIG_From_int(static_cast< int >(aruco::DM_VIDEO_FAST))); + SWIG_Python_SetConstant(d, "CORNER_SUBPIX",SWIG_From_int(static_cast< int >(aruco::CORNER_SUBPIX))); + SWIG_Python_SetConstant(d, "CORNER_LINES",SWIG_From_int(static_cast< int >(aruco::CORNER_LINES))); + SWIG_Python_SetConstant(d, "CORNER_NONE",SWIG_From_int(static_cast< int >(aruco::CORNER_NONE))); SWIG_Python_SetConstant(d, "MarkerMap_NONE",SWIG_From_int(static_cast< int >(aruco::MarkerMap::NONE))); SWIG_Python_SetConstant(d, "MarkerMap_PIX",SWIG_From_int(static_cast< int >(aruco::MarkerMap::PIX))); SWIG_Python_SetConstant(d, "MarkerMap_METERS",SWIG_From_int(static_cast< int >(aruco::MarkerMap::METERS))); diff --git a/aruco_wrap.h b/aruco_wrap.h index 918c0fd..4d07233 100644 --- a/aruco_wrap.h +++ b/aruco_wrap.h @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.8 + * Version 3.0.12 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make diff --git a/setup.py b/setup.py index a9a1d71..cea43e7 100644 --- a/setup.py +++ b/setup.py @@ -4,6 +4,7 @@ from distutils.core import setup, Extension import shutil import sys +import glob # use python2/3 version of aruco if sys.version_info[0] < 3: @@ -13,22 +14,25 @@ sourcefiles = ['aruco_wrap.cxx'] +sourcefiles.extend(glob.glob("src/aruco/*.cpp")) +sourcefiles.extend(glob.glob("src/aruco/markerlabelers/*.cpp")) + extra_cpp_args = ["-std=c++11", "-Wall", "-Wunused-variable"] # Compiling on OSX does not work with openmp switch -if platform.system().lower() != "darwin": +if platform.system().lower() not in ("darwin", "osx"): extra_cpp_args.append("-fopenmp") aruco_module = Extension('_aruco', sources=sourcefiles, language="c++", extra_compile_args=extra_cpp_args, - include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "."], - libraries=["opencv_core", "opencv_imgproc", "opencv_calib3d", "opencv_highgui", "aruco"], + include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "src/"], + libraries=["opencv_core", "opencv_imgproc", "opencv_calib3d", "opencv_highgui", "opencv_ml"], library_dirs=["/usr/local/lib"]) setup(name='aruco', - version='3.0.4.2', + version='3.0.13.0', author="""ArUco: Rafael Muñoz Salinas, Python wrappers: Marcus Degenkolbe""", author_email='marcus@degenkolbe.eu', description="""ArUco Python wrappers""", diff --git a/src/aruco/CMakeLists.txt b/src/aruco/CMakeLists.txt new file mode 100644 index 0000000..836609d --- /dev/null +++ b/src/aruco/CMakeLists.txt @@ -0,0 +1,56 @@ +SET (LIBNAME ${EXTRALIBNAME}aruco) +set(sources + cameraparameters.cpp + cvdrawingutils.cpp + dictionary.cpp + ippe.cpp + marker.cpp + markerdetector.cpp + markerlabeler.cpp + markermap.cpp + posetracker.cpp + markerlabelers/dictionary_based.cpp + debug.cpp + markerlabelers/svmmarkers.cpp +) + +set(headers + aruco_export.h + cameraparameters.h + cvdrawingutils.h + dictionary.h + ippe.h + marker.h + markerdetector.h + markerlabeler.h + markermap.h + posetracker.h + markerlabelers/dictionary_based.h + timers.h + debug.h + aruco.h + markerlabelers/svmmarkers.h +) + +add_library(${LIBNAME} ${sources} ${headers}) + +set_target_properties(${LIBNAME} PROPERTIES # create *nix style library versions + symbolic links + DEFINE_SYMBOL ARUCO_DSO_EXPORTS + VERSION ${PROJECT_VERSION} + SOVERSION ${PROJECT_SOVERSION} + CLEAN_DIRECT_OUTPUT 1 # allow creating static and shared libs without conflicts + OUTPUT_NAME "${LIBNAME}${PROJECT_DLLVERSION}" # avoid conflicts between library and binary target names +) + +target_link_libraries(${LIBNAME} PUBLIC opencv_core) +target_link_libraries(${LIBNAME} PRIVATE opencv_imgproc opencv_calib3d opencv_features2d opencv_ml) + +INSTALL(TARGETS ${LIBNAME} + RUNTIME DESTINATION bin COMPONENT main # Install the dll file in bin directory + LIBRARY DESTINATION lib PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE COMPONENT main + ARCHIVE DESTINATION lib COMPONENT main) # Install the dll.a file in lib directory + +IF(ARUCO_DEVINSTALL) + install(FILES ${headers} DESTINATION include/aruco) +ENDIF() + diff --git a/src/include/aruco/aruco.h b/src/aruco/aruco.h similarity index 100% rename from src/include/aruco/aruco.h rename to src/aruco/aruco.h diff --git a/src/include/aruco/aruco_export.h b/src/aruco/aruco_export.h similarity index 100% rename from src/include/aruco/aruco_export.h rename to src/aruco/aruco_export.h diff --git a/src/aruco/cameraparameters.cpp b/src/aruco/cameraparameters.cpp new file mode 100644 index 0000000..5efd713 --- /dev/null +++ b/src/aruco/cameraparameters.cpp @@ -0,0 +1,609 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ +#include "cameraparameters.h" + +#include +#include + +#include +#include + +using namespace std; +namespace aruco +{ + CameraParameters::CameraParameters() + { + CameraMatrix = cv::Mat(); + Distorsion = cv::Mat(); + CamSize = cv::Size(-1, -1); + } + /**Creates the object from the info passed + * @param cameraMatrix 3x3 matrix (fx 0 cx, 0 fy cy, 0 0 1) + * @param distorsionCoeff 4x1 matrix (k1,k2,p1,p2) + * @param size image size + */ + CameraParameters::CameraParameters(cv::Mat cameraMatrix, cv::Mat distorsionCoeff, + cv::Size size) + { + setParams(cameraMatrix, distorsionCoeff, size); + } + /** + */ + CameraParameters::CameraParameters(const CameraParameters& CI) + { + CI.CameraMatrix.copyTo(CameraMatrix); + CI.Distorsion.copyTo(Distorsion); + CamSize = CI.CamSize; + } + + /** + */ + CameraParameters& CameraParameters::operator=(const CameraParameters& CI) + { + CI.CameraMatrix.copyTo(CameraMatrix); + CI.Distorsion.copyTo(Distorsion); + CamSize = CI.CamSize; + return *this; + } + void CameraParameters::clear(){ + CameraMatrix=cv::Mat(); + CamSize=cv::Size(-1,-1); + Distorsion=cv::Mat(); + } + /** + */ + void CameraParameters::setParams(cv::Mat cameraMatrix, cv::Mat distorsionCoeff, cv::Size size) + { + if (cameraMatrix.rows != 3 || cameraMatrix.cols != 3) + throw cv::Exception(9000, "invalid input cameraMatrix", "CameraParameters::setParams", __FILE__, __LINE__); + cameraMatrix.convertTo(CameraMatrix, CV_32FC1); + if (distorsionCoeff.total() < 4 || distorsionCoeff.total() >= 7) + throw cv::Exception(9000, "invalid input distorsionCoeff", "CameraParameters::setParams", __FILE__, + __LINE__); + cv::Mat auxD; + + distorsionCoeff.convertTo(Distorsion, CV_32FC1); + + // Distorsion.create(1,4,CV_32FC1); + // for (int i=0;i<4;i++) + // Distorsion.ptr(0)[i]=auxD.ptr(0)[i]; + + CamSize = size; + } + + /** + */ + cv::Point3f CameraParameters::getCameraLocation(const cv::Mat &Rvec,const cv::Mat &Tvec) + { + + cv::Mat m33(3, 3, CV_32FC1); + cv::Rodrigues(Rvec, m33); + + cv::Mat m44 = cv::Mat::eye(4, 4, CV_32FC1); + for (int i = 0; i < 3; i++) + for (int j = 0; j < 3; j++) + m44.at(i, j) = m33.at(i, j); + + // now, add translation information + for (int i = 0; i < 3; i++) + m44.at(i, 3) = Tvec.ptr(0)[i]; + + + // invert the matrix + m44.inv(); + return cv::Point3f(m44.at(0, 3), m44.at(1, 3), m44.at(2, 3)); + } + + /**Saves this to a file + */ + void CameraParameters::saveToFile(string path, bool inXML) + { + if (!isValid()) + throw cv::Exception(9006, "invalid object", "CameraParameters::saveToFile", __FILE__, __LINE__); + if (!inXML) + { + ofstream file(path.c_str()); + if (!file) + throw cv::Exception(9006, "could not open file:" + path, "CameraParameters::saveToFile", __FILE__, + __LINE__); + file << "# Aruco 1.0 CameraParameters" << endl; + file << "fx = " << CameraMatrix.at(0, 0) << endl; + file << "cx = " << CameraMatrix.at(0, 2) << endl; + file << "fy = " << CameraMatrix.at(1, 1) << endl; + file << "cy = " << CameraMatrix.at(1, 2) << endl; + file << "k1 = " << Distorsion.at(0, 0) << endl; + file << "k2 = " << Distorsion.at(1, 0) << endl; + file << "p1 = " << Distorsion.at(2, 0) << endl; + file << "p2 = " << Distorsion.at(3, 0) << endl; + file << "width = " << CamSize.width << endl; + file << "height = " << CamSize.height << endl; + } + else + { + cv::FileStorage fs(path, cv::FileStorage::WRITE); + fs << "image_width" << CamSize.width; + fs << "image_height" << CamSize.height; + fs << "camera_matrix" << CameraMatrix; + fs << "distortion_coefficients" << Distorsion; + } + } + + /**Adjust the parameters to the size of the image indicated + */ + void CameraParameters::resize(cv::Size size) + { + if (!isValid()) + throw cv::Exception(9007, "invalid object", "CameraParameters::resize", __FILE__, __LINE__); + if (size == CamSize) + return; + // now, read the camera size + // resize the camera parameters to fit this image size + float AxFactor = float(size.width) / float(CamSize.width); + float AyFactor = float(size.height) / float(CamSize.height); + CameraMatrix.at(0, 0) *= AxFactor; + CameraMatrix.at(0, 2) *= AxFactor; + CameraMatrix.at(1, 1) *= AyFactor; + CameraMatrix.at(1, 2) *= AyFactor; + CamSize = size; + } + + /**** + * + * + * + * + */ + void CameraParameters::readFromXMLFile(string filePath) + { + cv::FileStorage fs(filePath, cv::FileStorage::READ); + if(!fs.isOpened()) throw std::runtime_error("CameraParameters::readFromXMLFile could not open file:"+filePath); + int w = -1, h = -1; + cv::Mat MCamera, MDist; + + + fs["image_width"] >> w; + fs["image_height"] >> h; + fs["distortion_coefficients"] >> MDist; + fs["camera_matrix"] >> MCamera; + + if (MCamera.cols == 0 || MCamera.rows == 0){ + fs["Camera_Matrix"] >> MCamera; + if (MCamera.cols == 0 || MCamera.rows == 0) + throw cv::Exception(9007, "File :" + filePath + " does not contains valid camera matrix", + "CameraParameters::readFromXML", __FILE__, __LINE__); + } + + if (w == -1 || h == 0){ + fs["image_Width"] >> w; + fs["image_Height"] >> h; + if (w == -1 || h == 0) + throw cv::Exception(9007, "File :" + filePath + " does not contains valid camera dimensions", + "CameraParameters::readFromXML", __FILE__, __LINE__); + } + if (MCamera.type() != CV_32FC1) + MCamera.convertTo(CameraMatrix, CV_32FC1); + else + CameraMatrix = MCamera; + + if (MDist.total() < 4){ + fs["Distortion_Coefficients"] >> MDist; + if (MDist.total() < 4) + throw cv::Exception(9007, "File :" + filePath + " does not contains valid distortion_coefficients", + "CameraParameters::readFromXML", __FILE__, __LINE__); + } + // convert to 32 and get the 4 first elements only + cv::Mat mdist32; + MDist.convertTo(mdist32, CV_32FC1); + // Distorsion.create(1,4,CV_32FC1); + // for (int i=0;i<4;i++) + // Distorsion.ptr(0)[i]=mdist32.ptr(0)[i]; + + Distorsion.create(1, 5, CV_32FC1); + for (int i = 0; i < 5; i++) + Distorsion.ptr(0)[i] = mdist32.ptr(0)[i]; + CamSize.width = w; + CamSize.height = h; + } + /**** + * + */ + void CameraParameters::glGetProjectionMatrix(cv::Size orgImgSize, cv::Size size, double proj_matrix[16], + double gnear, double gfar, bool invert) + { + if (cv::countNonZero(Distorsion) != 0) + std::cerr << "CameraParameters::glGetProjectionMatrix :: The camera has distortion coefficients " + << __FILE__ << " " << __LINE__ << endl; + if (isValid() == false) + throw cv::Exception(9100, "invalid camera parameters", "CameraParameters::glGetProjectionMatrix", __FILE__, + __LINE__); + + // Deterime the rsized info + double Ax = double(size.width) / double(orgImgSize.width); + double Ay = double(size.height) / double(orgImgSize.height); + double _fx = CameraMatrix.at(0, 0) * Ax; + double _cx = CameraMatrix.at(0, 2) * Ax; + double _fy = CameraMatrix.at(1, 1) * Ay; + double _cy = CameraMatrix.at(1, 2) * Ay; + double cparam[3][4] = {{_fx, 0, _cx, 0}, {0, _fy, _cy, 0}, {0, 0, 1, 0}}; + + argConvGLcpara2(cparam, size.width, size.height, gnear, gfar, proj_matrix, invert); + } + + /******************* + * + * + *******************/ + double CameraParameters::norm(double a, double b, double c) + { + return (sqrt(a * a + b * b + c * c)); + } + + /******************* + * + * + *******************/ + + double CameraParameters::dot(double a1, double a2, double a3, double b1, double b2, double b3) + { + return (a1 * b1 + a2 * b2 + a3 * b3); + } + + /******************* + * + * + *******************/ + + void CameraParameters::argConvGLcpara2(double cparam[3][4], int width, int height, double gnear, double gfar, + double m[16], bool invert) + { + double icpara[3][4]; + double trans[3][4]; + double p[3][3], q[4][4]; + int i, j; + + cparam[0][2] *= -1.0; + cparam[1][2] *= -1.0; + cparam[2][2] *= -1.0; + + if (arParamDecompMat(cparam, icpara, trans) < 0) + throw cv::Exception(9002, "parameter error", "MarkerDetector::argConvGLcpara2", __FILE__, __LINE__); + + for (i = 0; i < 3; i++) + { + for (j = 0; j < 3; j++) + { + p[i][j] = icpara[i][j] / icpara[2][2]; + } + } + q[0][0] = (2.0 * p[0][0] / width); + q[0][1] = (2.0 * p[0][1] / width); + q[0][2] = ((2.0 * p[0][2] / width) - 1.0); + q[0][3] = 0.0; + + q[1][0] = 0.0; + q[1][1] = (2.0 * p[1][1] / height); + q[1][2] = ((2.0 * p[1][2] / height) - 1.0); + q[1][3] = 0.0; + + q[2][0] = 0.0; + q[2][1] = 0.0; + q[2][2] = (gfar + gnear) / (gfar - gnear); + q[2][3] = -2.0 * gfar * gnear / (gfar - gnear); + + q[3][0] = 0.0; + q[3][1] = 0.0; + q[3][2] = 1.0; + q[3][3] = 0.0; + + for (i = 0; i < 4; i++) + { + for (j = 0; j < 3; j++) + { + m[i + j * 4] = q[i][0] * trans[0][j] + q[i][1] * trans[1][j] + q[i][2] * trans[2][j]; + } + m[i + 3 * 4] = q[i][0] * trans[0][3] + q[i][1] * trans[1][3] + q[i][2] * trans[2][3] + q[i][3]; + } + + if (!invert) + { + m[13] = -m[13]; + m[1] = -m[1]; + m[5] = -m[5]; + m[9] = -m[9]; + } + } + /******************* + * + * + *******************/ + + int CameraParameters::arParamDecompMat(double source[3][4], double cpara[3][4], + double trans[3][4]) + { + int r, c; + double Cpara[3][4]; + double rem1, rem2, rem3; + + if (source[2][3] >= 0) + { + for (r = 0; r < 3; r++) + { + for (c = 0; c < 4; c++) + { + Cpara[r][c] = source[r][c]; + } + } + } + else + { + for (r = 0; r < 3; r++) + { + for (c = 0; c < 4; c++) + { + Cpara[r][c] = -(source[r][c]); + } + } + } + + for (r = 0; r < 3; r++) + { + for (c = 0; c < 4; c++) + { + cpara[r][c] = 0.0; + } + } + cpara[2][2] = norm(Cpara[2][0], Cpara[2][1], Cpara[2][2]); + trans[2][0] = Cpara[2][0] / cpara[2][2]; + trans[2][1] = Cpara[2][1] / cpara[2][2]; + trans[2][2] = Cpara[2][2] / cpara[2][2]; + trans[2][3] = Cpara[2][3] / cpara[2][2]; + + cpara[1][2] = dot(trans[2][0], trans[2][1], trans[2][2], Cpara[1][0], Cpara[1][1], Cpara[1][2]); + rem1 = Cpara[1][0] - cpara[1][2] * trans[2][0]; + rem2 = Cpara[1][1] - cpara[1][2] * trans[2][1]; + rem3 = Cpara[1][2] - cpara[1][2] * trans[2][2]; + cpara[1][1] = norm(rem1, rem2, rem3); + trans[1][0] = rem1 / cpara[1][1]; + trans[1][1] = rem2 / cpara[1][1]; + trans[1][2] = rem3 / cpara[1][1]; + + cpara[0][2] = dot(trans[2][0], trans[2][1], trans[2][2], Cpara[0][0], Cpara[0][1], Cpara[0][2]); + cpara[0][1] = dot(trans[1][0], trans[1][1], trans[1][2], Cpara[0][0], Cpara[0][1], Cpara[0][2]); + rem1 = Cpara[0][0] - cpara[0][1] * trans[1][0] - cpara[0][2] * trans[2][0]; + rem2 = Cpara[0][1] - cpara[0][1] * trans[1][1] - cpara[0][2] * trans[2][1]; + rem3 = Cpara[0][2] - cpara[0][1] * trans[1][2] - cpara[0][2] * trans[2][2]; + cpara[0][0] = norm(rem1, rem2, rem3); + trans[0][0] = rem1 / cpara[0][0]; + trans[0][1] = rem2 / cpara[0][0]; + trans[0][2] = rem3 / cpara[0][0]; + + trans[1][3] = (Cpara[1][3] - cpara[1][2] * trans[2][3]) / cpara[1][1]; + trans[0][3] = (Cpara[0][3] - cpara[0][1] * trans[1][3] - cpara[0][2] * trans[2][3]) / cpara[0][0]; + + for (r = 0; r < 3; r++) + { + for (c = 0; c < 3; c++) + { + cpara[r][c] /= cpara[2][2]; + } + } + + return 0; + } + + /****** + * + */ + void CameraParameters::OgreGetProjectionMatrix(cv::Size orgImgSize, cv::Size size, double proj_matrix[16], + double gnear, double gfar, bool invert) + { + double temp_matrix[16]; + (*this).glGetProjectionMatrix(orgImgSize, size, temp_matrix, gnear, gfar, invert); + proj_matrix[0] = -temp_matrix[0]; + proj_matrix[1] = -temp_matrix[4]; + proj_matrix[2] = -temp_matrix[8]; + proj_matrix[3] = temp_matrix[12]; + + proj_matrix[4] = -temp_matrix[1]; + proj_matrix[5] = -temp_matrix[5]; + proj_matrix[6] = -temp_matrix[9]; + proj_matrix[7] = temp_matrix[13]; + + proj_matrix[8] = -temp_matrix[2]; + proj_matrix[9] = -temp_matrix[6]; + proj_matrix[10] = -temp_matrix[10]; + proj_matrix[11] = temp_matrix[14]; + + proj_matrix[12] = -temp_matrix[3]; + proj_matrix[13] = -temp_matrix[7]; + proj_matrix[14] = -temp_matrix[11]; + proj_matrix[15] = temp_matrix[15]; + } + /****** + * + */ + + cv::Mat CameraParameters::getRTMatrix(const cv::Mat& R_, const cv::Mat& T_, int forceType) + { + cv::Mat M; + cv::Mat R, T; + R_.copyTo(R); + T_.copyTo(T); + if (R.type() == CV_64F) + { + assert(T.type() == CV_64F); + cv::Mat Matrix = cv::Mat::eye(4, 4, CV_64FC1); + + cv::Mat R33 = cv::Mat(Matrix, cv::Rect(0, 0, 3, 3)); + if (R.total() == 3) + { + cv::Rodrigues(R, R33); + } + else if (R.total() == 9) + { + cv::Mat R64; + R.convertTo(R64, CV_64F); + R.copyTo(R33); + } + for (int i = 0; i < 3; i++) + Matrix.at(i, 3) = T.ptr(0)[i]; + M = Matrix; + } + else if (R.depth() == CV_32F) + { + cv::Mat Matrix = cv::Mat::eye(4, 4, CV_32FC1); + cv::Mat R33 = cv::Mat(Matrix, cv::Rect(0, 0, 3, 3)); + if (R.total() == 3) + { + cv::Rodrigues(R, R33); + } + else if (R.total() == 9) + { + cv::Mat R32; + R.convertTo(R32, CV_32F); + R.copyTo(R33); + } + + for (int i = 0; i < 3; i++) + Matrix.at(i, 3) = T.ptr(0)[i]; + M = Matrix; + } + + if (forceType == -1) + return M; + else + { + cv::Mat MTyped; + M.convertTo(MTyped, forceType); + return MTyped; + } + } + std::ostream &operator<<(std::ostream &str,const CameraParameters&cp){ + str<<"%YAML:1.0"<(0); + for(int i=0;i<9;i++){ + str<(); + for(int i=0;i<5;i++){ + str<>(std::istream &str,CameraParameters&cp){ + + auto getValue=[](string line){ + //remove ':' + for(auto &c:line) if (c==':') c=' '; + stringstream ss; + ss<>aux>>val; + return val; + }; + + auto parseDataLine=[](string line,cv::Mat &data){ + //remove + for(auto &c:line) + if (c=='[' || c==']'|| c==',' || c==':') c=' '; + //now, read + stringstream sstr;sstr<>sdata; + for(size_t i=0;i>data.ptr(0)[i]; + }; + + cp.CameraMatrix=cv::Mat::eye(3,3,CV_32F); + cp.Distorsion.create(1,5,CV_32F); + cp.Distorsion.setTo(cv::Scalar::all(0)); + string line; + std::getline(str,line); + if (line.find("%YAML:1.0")==string::npos){ + std::cerr<<"Invalid input stream"< +#include #include #include @@ -43,7 +43,7 @@ namespace aruco public: // 3x3 matrix (fx 0 cx, 0 fy cy, 0 0 1) cv::Mat CameraMatrix; - // 4x1 matrix (k1,k2,p1,p2) + // distortion matrix cv::Mat Distorsion; // size of the image cv::Size CamSize; @@ -90,11 +90,12 @@ namespace aruco */ void resize(cv::Size size); - /**Returns the location of the camera in the reference system given by the rotation and translation vectors - * passed + /**Returns the location of the camera in the reference system of the marker. + * + * Rvec and Tvec are the transform from the marker to the camera as calculated in other parts of the library * NOT TESTED */ - static cv::Point3f getCameraLocation(cv::Mat Rvec, cv::Mat Tvec); + static cv::Point3f getCameraLocation(const cv::Mat &Rvec,const cv::Mat &Tvec); /**Given the intrinsic camera parameters returns the GL_PROJECTION matrix for opengl. * PLease NOTE that when using OpenGL, it is assumed no camera distorsion! So, if it is not true, you should have @@ -130,6 +131,10 @@ namespace aruco static cv::Mat getRTMatrix(const cv::Mat& R_, const cv::Mat& T_, int forceType); + /**Makes this invalid + */ + void clear(); + ARUCO_EXPORT friend std::ostream &operator<<(std::ostream &str,const CameraParameters&cp); ARUCO_EXPORT friend std::istream &operator>>(std::istream &str,CameraParameters&cp); private: diff --git a/src/aruco/cvdrawingutils.cpp b/src/aruco/cvdrawingutils.cpp new file mode 100644 index 0000000..9b8b340 --- /dev/null +++ b/src/aruco/cvdrawingutils.cpp @@ -0,0 +1,174 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ +#include +#include +#include "cvdrawingutils.h" +#include "cameraparameters.h" +using namespace cv; +namespace aruco +{ +void CvDrawingUtils::draw3dAxis(cv::Mat& Image, const CameraParameters& CP, const cv::Mat& Rvec, + const cv::Mat& Tvec, float axis_size) + { + Mat objectPoints(4, 3, CV_32FC1); + objectPoints.at(0, 0) = 0; + objectPoints.at(0, 1) = 0; + objectPoints.at(0, 2) = 0; + objectPoints.at(1, 0) = axis_size; + objectPoints.at(1, 1) = 0; + objectPoints.at(1, 2) = 0; + objectPoints.at(2, 0) = 0; + objectPoints.at(2, 1) = axis_size; + objectPoints.at(2, 2) = 0; + objectPoints.at(3, 0) = 0; + objectPoints.at(3, 1) = 0; + objectPoints.at(3, 2) = axis_size; + + std::vector imagePoints; + cv::projectPoints(objectPoints, Rvec, Tvec, CP.CameraMatrix, CP.Distorsion, imagePoints); + // draw lines of different colours + cv::line(Image, imagePoints[0], imagePoints[1], Scalar(0, 0, 255, 255), 1); + cv::line(Image, imagePoints[0], imagePoints[2], Scalar(0, 255, 0, 255), 1); + cv::line(Image, imagePoints[0], imagePoints[3], Scalar(255, 0, 0, 255), 1); + putText(Image, "x", imagePoints[1], FONT_HERSHEY_SIMPLEX, 0.6, Scalar(0, 0, 255, 255), 2); + putText(Image, "y", imagePoints[2], FONT_HERSHEY_SIMPLEX, 0.6, Scalar(0, 255, 0, 255), 2); + putText(Image, "z", imagePoints[3], FONT_HERSHEY_SIMPLEX, 0.6, Scalar(255, 0, 0, 255), 2); + } + /**** + * + * + * + ****/ + void CvDrawingUtils::draw3dAxis(cv::Mat& Image, Marker& m, const CameraParameters& CP,int lineSize) + { + float size = m.ssize *0.6; + Mat objectPoints(4, 3, CV_32FC1); + objectPoints.at(0, 0) = 0; + objectPoints.at(0, 1) = 0; + objectPoints.at(0, 2) = 0; + objectPoints.at(1, 0) = size; + objectPoints.at(1, 1) = 0; + objectPoints.at(1, 2) = 0; + objectPoints.at(2, 0) = 0; + objectPoints.at(2, 1) = size; + objectPoints.at(2, 2) = 0; + objectPoints.at(3, 0) = 0; + objectPoints.at(3, 1) = 0; + objectPoints.at(3, 2) = size; + + std::vector imagePoints; + cv::projectPoints(objectPoints, m.Rvec, m.Tvec, CP.CameraMatrix, CP.Distorsion, imagePoints); + // draw lines of different colours + cv::line(Image, imagePoints[0], imagePoints[1], Scalar(0, 0, 255, 255), lineSize); + cv::line(Image, imagePoints[0], imagePoints[2], Scalar(0, 255, 0, 255), lineSize); + cv::line(Image, imagePoints[0], imagePoints[3], Scalar(255, 0, 0, 255), lineSize); + putText(Image, "x", imagePoints[1], FONT_HERSHEY_SIMPLEX, 0.6, Scalar(0, 0, 255, 255), 2); + putText(Image, "y", imagePoints[2], FONT_HERSHEY_SIMPLEX, 0.6, Scalar(0, 255, 0, 255), 2); + putText(Image, "z", imagePoints[3], FONT_HERSHEY_SIMPLEX, 0.6, Scalar(255, 0, 0, 255), 2); + } + + /**** + * + * + * + ****/ + void CvDrawingUtils::draw3dCube(cv::Mat& Image, Marker& m, const CameraParameters& CP, int lineSize, bool setYperpendicular) + { + Mat objectPoints(8, 3, CV_32FC1); + float halfSize = m.ssize / 2.f; + + if (setYperpendicular) + { + objectPoints.at(0, 0) = -halfSize; + objectPoints.at(0, 1) = 0; + objectPoints.at(0, 2) = -halfSize; + objectPoints.at(1, 0) = halfSize; + objectPoints.at(1, 1) = 0; + objectPoints.at(1, 2) = -halfSize; + objectPoints.at(2, 0) = halfSize; + objectPoints.at(2, 1) = 0; + objectPoints.at(2, 2) = halfSize; + objectPoints.at(3, 0) = -halfSize; + objectPoints.at(3, 1) = 0; + objectPoints.at(3, 2) = halfSize; + + objectPoints.at(4, 0) = -halfSize; + objectPoints.at(4, 1) = m.ssize; + objectPoints.at(4, 2) = -halfSize; + objectPoints.at(5, 0) = halfSize; + objectPoints.at(5, 1) = m.ssize; + objectPoints.at(5, 2) = -halfSize; + objectPoints.at(6, 0) = halfSize; + objectPoints.at(6, 1) = m.ssize; + objectPoints.at(6, 2) = halfSize; + objectPoints.at(7, 0) = -halfSize; + objectPoints.at(7, 1) = m.ssize; + objectPoints.at(7, 2) = halfSize; + } + else + { + objectPoints.at(0, 0) = -halfSize; + objectPoints.at(0, 1) = -halfSize; + objectPoints.at(0, 2) = 0; + objectPoints.at(1, 0) = halfSize; + objectPoints.at(1, 1) = -halfSize; + objectPoints.at(1, 2) = 0; + objectPoints.at(2, 0) = halfSize; + objectPoints.at(2, 1) = halfSize; + objectPoints.at(2, 2) = 0; + objectPoints.at(3, 0) = -halfSize; + objectPoints.at(3, 1) = halfSize; + objectPoints.at(3, 2) = 0; + + objectPoints.at(4, 0) = -halfSize; + objectPoints.at(4, 1) = -halfSize; + objectPoints.at(4, 2) = m.ssize; + objectPoints.at(5, 0) = halfSize; + objectPoints.at(5, 1) = -halfSize; + objectPoints.at(5, 2) = m.ssize; + objectPoints.at(6, 0) = halfSize; + objectPoints.at(6, 1) = halfSize; + objectPoints.at(6, 2) = m.ssize; + objectPoints.at(7, 0) = -halfSize; + objectPoints.at(7, 1) = halfSize; + objectPoints.at(7, 2) = m.ssize; + } + + std::vector imagePoints; + projectPoints(objectPoints, m.Rvec, m.Tvec, CP.CameraMatrix, CP.Distorsion, imagePoints); + // draw lines of different colours + for (int i = 0; i < 4; i++) + cv::line(Image, imagePoints[i], imagePoints[(i + 1) % 4], Scalar(0, 0, 255, 255), lineSize); + + for (int i = 0; i < 4; i++) + cv::line(Image, imagePoints[i + 4], imagePoints[4 + (i + 1) % 4], Scalar(0, 0, 255, 255), lineSize); + + for (int i = 0; i < 4; i++) + cv::line(Image, imagePoints[i], imagePoints[i + 4], Scalar(0, 0, 255, 255), lineSize); + } +} diff --git a/src/include/aruco/cvdrawingutils.h b/src/aruco/cvdrawingutils.h similarity index 95% rename from src/include/aruco/cvdrawingutils.h rename to src/aruco/cvdrawingutils.h index b2aedd8..4d08922 100644 --- a/src/include/aruco/cvdrawingutils.h +++ b/src/aruco/cvdrawingutils.h @@ -39,12 +39,12 @@ namespace aruco class ARUCO_EXPORT CvDrawingUtils { public: + static void draw3dAxis(cv::Mat& Image, const CameraParameters& CP, const cv::Mat& Rvec, const cv::Mat& Tvec, float axis_size); + static void draw3dAxis(cv::Mat& Image, Marker& m, const CameraParameters& CP,int lineSize=1); - static void draw3dAxis(cv::Mat& Image, Marker& m, const CameraParameters& CP); - - static void draw3dCube(cv::Mat& Image, Marker& m, const CameraParameters& CP, bool setYperpendicular = false); + static void draw3dCube(cv::Mat& Image, Marker& m, const CameraParameters& CP,int lineSize=1, bool setYperpendicular = false); // static void draw3dAxis(cv::Mat &Image, MarkerMap &m, const CameraParameters &CP); // static void draw3dCube(cv::Mat &Image, MarkerMap &m, const CameraParameters &CP, bool setYperpendicular = diff --git a/src/aruco/debug.cpp b/src/aruco/debug.cpp new file mode 100644 index 0000000..42b498f --- /dev/null +++ b/src/aruco/debug.cpp @@ -0,0 +1,67 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "debug.h" +#include + namespace aruco{ +int Debug::level=2; +std::map Debug::strings; +void Debug::addString(std::string &label, std::string &data){ + strings.insert(make_pair(label,data)); +} + +std::string Debug::getString(std::string &str){ + auto it=strings.find(str); + if (it==strings.end())return ""; + else return it->second; +} + + +bool Debug::isInited=false; + +void Debug::setLevel ( int l ) { + level=l; + isInited=false; + init(); +} +int Debug::getLevel() { + init(); + return level; +} +void Debug::init() { + if ( !isInited ) { + isInited=true; + if ( level>=1 ) { + } + } + +} + + +} + diff --git a/src/include/aruco/debug.h b/src/aruco/debug.h similarity index 100% rename from src/include/aruco/debug.h rename to src/aruco/debug.h diff --git a/src/aruco/dictionary.cpp b/src/aruco/dictionary.cpp new file mode 100644 index 0000000..bb31372 --- /dev/null +++ b/src/aruco/dictionary.cpp @@ -0,0 +1,538 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "dictionary.h" +#include +#include +#include +#include +#include +#include +#include +#include "markermap.h" +#include +#include +using namespace std; +namespace aruco{ + + +Dictionary Dictionary::load(string info){ +if (isPredefinedDictinaryString(info)) + return loadPredefined(info); +else return loadFromFile(info); +} + + +Dictionary Dictionary::loadFromFile(std::string path) { + auto parse=[](const string &str){ + stringstream sstr(str); + string a,b; + sstr>>a>>b;return b; + }; + auto _stoi=[](string str){ + int i;sscanf(str.c_str(),"%d",&i);return i; + }; + + ifstream file(path); + if (!file)throw std::runtime_error("Dictionary::loadFromFile could not open file"); + string line; + std::getline(file,line); + if (line.find("name")==std::string::npos) throw std::runtime_error("Dictionary::loadFromFile 'name' not found"); + Dictionary d; + d._name=parse(line); + std::getline(file,line); + if (line.find("nbits")==std::string::npos) throw std::runtime_error("Dictionary::loadFromFile 'nbits' not found"); + d._nbits=_stoi(parse(line)); + if (d._nbits>64)throw std::runtime_error("Dictionary::loadFromFile no more than 64 bits allowed "); + + + d._type=CUSTOM; + //go reading the data + while(!file.eof()){ + std::getline(file,line); + if (line.size()==d._nbits){ + bitset<64> marker; + //parse the bits + int idx=0; + for(auto it=line.rbegin();it!=line.rend() ;it++){ + marker[idx++]=*it=='1'; + } + d._code_id.insert({marker.to_ullong(), static_cast(d._code_id.size())}); + } + } + d._tau= static_cast(computeDictionaryDistance(d)); + if (d._tau==0){ + cerr<<"IMPORTANT MESSAGE:::: Your dictionary "< codes={0xf89c68ea2UL,0xf021c83fdUL,0x9b2f835a2UL,0xf8ffdb019UL,0xf2d12b272UL,0xf0e6afe8bUL,0xe19dee435UL,0xdbe424132UL,0xa9885a341UL,0x3add1e6caUL,0x600aa0d15UL,0xf9d5c0938UL,0xf85b0f3d4UL,0xf838bcd6fUL,0xfa6c8bf2dUL,0xfb469060cUL,0xfb25238b7UL,0xff8d4dc33UL,0xfc3406a26UL,0xfc57b549dUL,0xfcf361750UL,0xfd7daedbcUL,0xf42d724b4UL,0xf1ccb47aaUL,0xe1fe5da8eUL,0xe2e3c2f56UL,0xe280711edUL,0xe224a5220UL,0xe36d0d5baUL,0xed2cf4e23UL,0xecc188a74UL,0xcf7ea3892UL,0xcca45b03cUL,0xc4de9c015UL,0xc0b1959e7UL,0xd027a870eUL,0xd1a967de2UL,0xd3fd50fa0UL,0xd67f25205UL,0xdcf5013a3UL,0xdea1361e1UL,0xdb8797f89UL,0xd8f9bb4eaUL,0x98321c07aUL,0x9dd3da364UL,0x9162c0972UL,0x91c614abfUL,0x81339aaedUL,0x3f3cd85d4UL,0x3907e6e64UL,0x2231e480aUL,0x287ca74daUL,0xee52d854UL,0x3b94b615UL,0x1ab8cdc82UL,0x4463c9014UL,0x6588d50b0UL,0xf912a744eUL,0xf97114af5UL,0xfb81f7b7aUL,0xfbe2445c1UL,0xff4a2a145UL,0xfea756512UL,0xfe03826dfUL,0xfc90d29ebUL,0xfdbac90caUL,0xfdd97ae71UL,0xf564da32eUL,0xf5c00e0e3UL,0xf679456f6UL,0xf6be22b80UL,0xf6dd9153bUL,0xf7f78ac1aUL,0xf35fe489eUL,0xf33c57625UL,0xf398835e8UL,0xf3fb30b53UL,0xf2b298cc9UL,0xf2164cf04UL,0xf275ff1bfUL,0xf10bd3adcUL,0xf16860467UL,0xe1393a7f8UL,0xe07092062UL,0xe0b7f5d14UL,0xe0d4463afUL,0xe7c56313eUL,0xe7a6d0f85UL,0xe70204c48UL,0xe6281f569UL,0xe47c2872bUL,0xed8820deeUL,0xedeb93355UL,0xed4f47098UL,0xec06ef702UL,0xeef60c68dUL,0xef78c3c61UL,0xefbfa4117UL,0xebb31e65eUL,0xebd0ad8e5UL,0xeb7479b28UL,0xeb17ca593UL,0xea5e62209UL,0xeafab61c4UL,0xe8ae81386UL,0xe9204e96aUL,0xe9e72941cUL,0xe9849aaa7UL,0xc86f86a03UL,0xc9e1490efUL,0xcbb57e2adUL,0xcb7219fdbUL,0xca58026faUL,0xca9f65b8cUL,0xcef06c27eUL,0xce54b81b3UL,0xcf1d10629UL,0xcd8e4091dUL,0xcc633cd4aUL,0xccc7e8e87UL,0xc7c3035cdUL,0xc767d7600UL,0xc62e7f19aUL,0xc64dccf21UL,0xc6e918cecUL,0xc68aab257UL,0xc2861151eUL,0xc24176868UL,0xc15ce9db0UL,0xc0d22675cUL,0xd0e0cfa78UL,0xd0837c4c3UL,0xd16e00094UL,0xd2739f54cUL,0xd2102cbf7UL,0xd6dbf11c8UL,0xd79259652UL,0xd7368d59fUL,0xd562ba7ddUL,0xd5c66e410UL,0xd5a5ddaabUL,0xd48fc638aUL,0xd4ec75d31UL,0xdc96b2d18UL,0xddbca9439UL,0xdf4c4a5b6UL,0xde05e222cUL,0xdaad8c6a8UL,0xdace3f813UL,0xd9b013370UL,0xd9d3a0dcbUL,0xd85d6f727UL,0x9aa14cf4eUL,0x9ac2ff1f5UL,0x9b4c30b19UL,0x9be8e48d4UL,0x9b8b5766fUL,0x99bcd3a96UL,0x99df6042dUL,0x96b482695UL,0x979e99fb4UL,0x95caaedf6UL,0x950dc9080UL,0x956e7ae3bUL,0x9427d29a1UL,0x908fbcd25UL,0x9392238fdUL,0x92b8381dcUL,0x824db618eUL,0x83c379b62UL,0x83041e614UL,0x81f4fd79bUL,0x80dee6ebaUL,0x8019813ccUL,0x853f20da4UL,0x87cfc3c2bUL,0x8e5878855UL,0x8fb504c02UL,0x8b1d6a886UL,0x8a93a526aUL,0xabdc6d103UL,0xaa3111554UL,0xaa52a2befUL,0xa8a241a60UL,0xa8c1f24dbUL,0xa92c8e08cUL,0xad438797eUL,0xa156490a5UL,0xa0d886a49UL,0xb04ebb4a0UL,0xb1c074e4cUL,0xb616361abUL,0xb73c2d88aUL,0xbf2559618UL,0xbd716e45aUL,0xb8347c489UL,0xb890a8744UL,0xba604b6cbUL,0xbb29e3151UL,0x3c42f4eb7UL,0x388929488UL,0x3b94b6150UL,0x33ee71179UL,0x311e920f6UL,0x30905da1aUL,0x343833e9eUL,0x35b6fc472UL,0x360fb7267UL,0x26998ac8eUL,0x271745662UL,0x20a2b473eUL,0x20c107985UL,0x2188afe1fUL,0x23bf2b2e6UL,0x229530bc7UL,0x2a2890698UL,0x2ba65fc74UL,0x281f14a61UL,0x2fc956586UL,0x2f6d8264bUL,0x2e80fe21cUL,0xe869e6efUL,0xc767d760UL,0x8bda0d5fUL,0xae997f1dUL,0xa2ef026bUL,0xb04ebb4aUL,0xb67585f1UL,0x37e2cb63UL,0x25437242UL,0x149a879aUL,0x69fea87dUL,0x71125291UL,0x1609d7694UL,0x143e53a6dUL,0x11bc267c8UL,0x12c20acabUL,0x132f768fcUL,0x134cc5647UL,0x1a1c19f4fUL,0x182b9d3b6UL,0x1c27274ffUL,0x5a10d96a9UL,0x50f94e9b4UL,0x509afd70fUL,0x57e86bb25UL,0x56c270204UL,0x477e565ccUL,0x43115fc3eUL,0x493fafe55UL,0x48b1604b9UL,0x4a2230b8dUL,0x6cd8099b8UL,0x6d3575defUL,0x6bc92cb29UL,0x687067d3cUL,0x652c0137dUL,0x757d5b0e2UL,0x76a7a384cUL,0x72ab19f05UL,0x73e2b189fUL,0x709c9d3fcUL,0x7885e9d6eUL,0x7bfbc560dUL,0x7e79b0ba8UL,0x7dc0fbdbdUL,0x7d642fe70UL,0x7c4e34751UL,0xf9b673783UL,0xfa0f38196UL,0xfac85fce0UL,0xfaabec25bUL,0xff2999ffeUL,0xfec4e5ba9UL,0xfd1e1d307UL,0xf50769d95UL,0xf5a3bde58UL,0xf489a6779UL,0xf44ec1a0fUL,0xf794392a1UL,0xf7535efd7UL,0xf0427bd46UL,0xf1af07911UL,0xe15a89943UL,0xe01321ed9UL,0xe24716c9bUL,0xe30ebeb01UL,0xe3aa6a8ccUL,0xe3c9d9677UL,0xe761b72f3UL,0xe64bacbd2UL,0xe68ccb6a4UL,0xe4d8fc4e6UL,0xe4bb4fa5dUL,0xe41f9b990UL,0xe55633e0aUL,0xe535800b1UL,0xe5915437cUL,0xe5f2e7dc7UL,0xec655c9b9UL,0xeca23b4cfUL,0xee95bf836UL,0xee52d8540UL,0xee316bbfbUL,0xef1b702daUL,0xefdc17facUL,0xea3dd1cb2UL,0xea9905f7fUL,0xe869e6ef0UL,0xe80a5504bUL,0xe943fd7d1UL,0xc8cb529ceUL,0xc8a8e1775UL,0xc80c354b8UL,0xc9459d322UL,0xc982fae54UL,0xcbd6cdc16UL,0xcb11aa160UL,0xca3bb1841UL,0xcafcd6537UL,0xce93dfcc5UL,0xce370bf08UL,0xcfb9c45e4UL,0xcfda77b5fUL,0xcdedf37a6UL,0xcd2a94ad0UL,0xcd492746bUL,0xcc008f3f1UL,0xc4bd2feaeUL,0xc419fbd63UL,0xc533e0442UL,0xc55053af9UL,0xc5f487934UL,0xc5973478fUL,0xc7a0b0b76UL,0xc704648bbUL,0xc2e5a2ba5UL,0xc308deff2UL,0xc19b8e0c6UL,0xc01541a2aUL,0xd0441b9b5UL,0xd1cad4359UL,0xd10db3e2fUL,0xd33a372d6UL,0xd35984c6dUL,0xd2b4f883aUL,0xd2d74b681UL,0xd50109966UL,0xd448a1efcUL,0xdc51d506eUL,0xdd187d7f4UL,0xdd7bce94fUL,0xdf2ff9b0dUL,0xdf8b2d8c0UL,0xdfe89e67bUL,0xdec285f5aUL,0xde6651c97UL,0xda6aebbdeUL,0xda0958565UL,0xdb2343c44UL,0xd97774e06UL,0xd914c70bdUL,0xd89a08a51UL,0xd83edc99cUL,0x9a662b238UL,0x9a0598c83UL,0x997bb47e0UL,0x99180795bUL,0x9851afec1UL,0x9896c83b7UL,0x9c9a724feUL,0x9cf9c1a45UL,0x9c5d15988UL,0x9c3ea6733UL,0x9d14bde12UL,0x9d770e0a9UL,0x9db069ddfUL,0x9f87ed126UL,0x9fe45ef9dUL,0x9f408ac50UL,0x9f23392ebUL,0x9e6a91571UL,0x9ece456bcUL,0x96d73182eUL,0x961056558UL,0x9673e5be3UL,0x9759fe2c2UL,0x973a4dc79UL,0x95a91d34dUL,0x94446171aUL,0x94e0b54d7UL,0x90ec0f39eUL,0x902b68ee8UL,0x9048db053UL,0x9101737c9UL,0x93f190646UL,0x93554458bUL,0x921cec211UL,0x82e962243UL,0x83a0ca5d9UL,0x8367ad8afUL,0x815029456UL,0x81974e920UL,0x80bd55001UL,0x807a32d77UL,0x847688a3eUL,0x84153b485UL,0x84b1ef748UL,0x84d25c9f3UL,0x85f8470d2UL,0x855c9331fUL,0x876b17fe6UL,0x87ac70290UL,0x86e5d850aUL,0x8622bf87cUL,0x8e3bcb6eeUL,0x8efcacb98UL,0x8f7263174UL,0x8f11d0fcfUL,0x8d2654336UL,0x8d45e7d8dUL,0x8de133e40UL,0x8d82800fbUL,0x8ca89b9daUL,0x8c6ffc4acUL,0x8c0c4fa17UL,0x8800f5d5eUL,0x8863463e5UL,0x88c792028UL,0x88a421e93UL,0x898e3a7b2UL,0x89ed89909UL,0x89495dac4UL,0x892aee47fUL,0x8bda0d5f0UL,0x8bb9beb4bUL,0x8af016cd1UL,0x8a54c2f1cUL,0x8a37711a7UL,0xab1b0ac75UL,0xaa95c5699UL,0xa86526716UL,0xa806959adUL,0xa9ebe9dfaUL,0xa94f3de37UL,0xad20347c5UL,0xade753ab3UL,0xaccd48392UL,0xacaefbd29UL,0xac0a2fee4UL,0xae5e18ca6UL,0xae3dab21dUL,0xae997f1d0UL,0xafd0d764aUL,0xafb3648f1UL,0xa70ec45aeUL,0xa76d77b15UL,0xa7c9a38d8UL,0xa7aa10663UL,0xa6800bf42UL,0xa6e3b81f9UL,0xa624dfc8fUL,0xa4135b076UL,0xa4d43cd00UL,0xa59d94a9aUL,0xa5fe27421UL,0xa55af37ecUL,0xa135fae1eUL,0xa1f29d368UL,0xa1912edd3UL,0xa0bb354f2UL,0xa24bd657dUL,0xa2ef026b0UL,0xa28cb180bUL,0xa3a6aa12aUL,0xa361cdc5cUL,0xa3027e2e7UL,0xb39443c0eUL,0xb3f7f02b5UL,0xb35324178UL,0xb33097fc3UL,0xb2793f859UL,0xb2ddebb94UL,0xb089dc9d6UL,0xb0ea6f76dUL,0xb02d08a1bUL,0xb1071333aUL,0xb164a0d81UL,0xb5af7d7beUL,0xb5ccce905UL,0xb5681aac8UL,0xb50ba9473UL,0xb421b2d52UL,0xb442013e9UL,0xb4e6d5024UL,0xb48566e9fUL,0xb6b2e2266UL,0xb6d151cddUL,0xb67585f10UL,0xb75f9e631UL,0xb7fb4a5fcUL,0xbfe23eb6eUL,0xbf46ea8a3UL,0xbe6cf1182UL,0xbeab96cf4UL,0xbec82524fUL,0xbc9c1200dUL,0xbc38c63c0UL,0xbc5b75d7bUL,0xbdb60992cUL,0xbdd5ba797UL,0xb9d9000deUL,0xb9bab3e65UL,0xb91e67da8UL,0xb857cfa32UL,0xb8f31b9ffUL,0xbac49f506UL,0xbaa72cbbdUL,0xba03f8870UL,0xbb4a50feaUL,0xbb8d3729cUL,0xbbee84c27UL,0x3e757024eUL,0x3e16c3cf5UL,0x3eb217f38UL,0x3ed1a4183UL,0x3ffbbf8a2UL,0x3f980c619UL,0x3f5f6bb6fUL,0x3d0b5c92dUL,0x3dcc3b45bUL,0x3ce620d7aUL,0x3c85933c1UL,0x3c214700cUL,0x384e4e9feUL,0x38ea9aa33UL,0x39c081312UL,0x39a332da9UL,0x3964550dfUL,0x3b53d1c26UL,0x3b306229dUL,0x3bf705febUL,0x3a1a79bbcUL,0x3a79ca507UL,0x32030d52eUL,0x3260beb95UL,0x32c46a858UL,0x32a7d96e3UL,0x338dc2fc2UL,0x334aa52b4UL,0x332916c0fUL,0x317d21e4dUL,0x31d9f5d80UL,0x31ba4633bUL,0x30f3ee4a1UL,0x30573a76cUL,0x3034899d7UL,0x345b80025UL,0x34ff543e8UL,0x349ce7d53UL,0x35d54fac9UL,0x3512287bfUL,0x37461f5fdUL,0x37e2cb630UL,0x37817888bUL,0x36ab631aaUL,0x36c8d0f11UL,0x366c04cdcUL,0x265eed1f8UL,0x2774f68d9UL,0x27b3915afUL,0x258415956UL,0x25e7a67edUL,0x254372420UL,0x2520c1a9bUL,0x240ada3baUL,0x246969d01UL,0x24cdbdeccUL,0x24ae0e077UL,0x2006604f3UL,0x23dc98c5dUL,0x23784cf90UL,0x231bff12bUL,0x2252576b1UL,0x22f68357cUL,0x2aeff7beeUL,0x2a8c44555UL,0x2a4b23823UL,0x2b6138102UL,0x29f268e36UL,0x29350f340UL,0x2956bcdfbUL,0x28d873717UL,0x2cd4c905eUL,0x2cb77aee5UL,0x2c13aed28UL,0x2d5a06ab2UL,0x2faae5b3dUL,0x2f0e318f0UL,0x2e4799f6aUL,0x2ee34dca7UL,0xfac85fceUL,0xf6be22b8UL,0xe224a522UL,0xe41f9b99UL,0xcd2a94adUL,0xd3fd50faUL,0x9f408ac5UL,0x950dc908UL,0x9336f7b3UL,0x81974e92UL,0x87ac7029UL,0x8de133e4UL,0xa4d43cd0UL,0xbc38c63cUL,0xba03f887UL,0x3daf88aeUL,0x31d9f5d8UL,0x29350f34UL,0xc767d76UL,0xa4d43cdUL,0x63b3ebbUL,0x12a1b921UL,0x1ed7c457UL,0x526a1e68UL,0x545120d3UL,0x40cba749UL,0x4a86e484UL,0x6fc596c6UL,0x63b3ebb0UL,0x77296c2aUL,0x7b5f115cUL,0x7d642fe7UL,0x17407f10eUL,0x1723ccfb5UL,0x17e4ab2c3UL,0x16ceb0be2UL,0x16ad03559UL,0x14f93471bUL,0x15d32fe3aUL,0x15b09c081UL,0x15144834cUL,0x1577fbdf7UL,0x117b41abeUL,0x1118f2405UL,0x11df95973UL,0x10963dee9UL,0x1032e9d24UL,0x1266def66UL,0x12056d1ddUL,0x12a1b9210UL,0x13e81158aUL,0x1b55b18d5UL,0x1bf165b18UL,0x1b92d65a3UL,0x1adb7e239UL,0x1a7faa1f4UL,0x18482ed0dUL,0x18ecfaec0UL,0x188f4907bUL,0x19a55295aUL,0x190186a97UL,0x1dca5b0a8UL,0x1da9e8e13UL,0x1c83f3732UL,0x1ce040989UL,0x1c4494a44UL,0x1e10a3806UL,0x1ed7c4570UL,0x1eb477bcbUL,0x1f9e6c2eaUL,0x1ffddfc51UL,0x1f590bf9cUL,0x1f3ab8127UL,0x5da5287f5UL,0x5d624fa83UL,0x5c2be7d19UL,0x5edb04c96UL,0x5e1c631e0UL,0x5e7fd0f5bUL,0x5f92acb0cUL,0x5ff11f5b7UL,0x5b9e16c45UL,0x5b5971133UL,0x5a736a812UL,0x5ab40d564UL,0x58e03a726UL,0x58838999dUL,0x596ef5dcaUL,0x59a9920bcUL,0x59ca21e07UL,0x51b0e6e2eUL,0x51d355095UL,0x511432de3UL,0x503e294c2UL,0x52ceca54dUL,0x526a1e680UL,0x5209ad83bUL,0x5323b611aUL,0x53e4d1c6cUL,0x5387622d7UL,0x574cbf8e8UL,0x572f0c653UL,0x560517f72UL,0x56a1c3cbfUL,0x549647046UL,0x54f5f4efdUL,0x545120d30UL,0x557b3b411UL,0x55bc5c967UL,0x45ed06af8UL,0x458eb5443UL,0x44a4aed62UL,0x44007aeafUL,0x4637fe256UL,0x46f099f20UL,0x47da82601UL,0x4372ec285UL,0x429f906d2UL,0x4258f7ba4UL,0x423b4451fUL,0x40cba7490UL,0x40a814a2bUL,0x41820f30aUL,0x41e1bcdb1UL,0x414568e7cUL,0x495c1c0eeUL,0x499b7bd98UL,0x49f8c8323UL,0x4815b4774UL,0x4a4183536UL,0x4a86e4840UL,0x4ae5576fbUL,0x4bcf4cfdaUL,0x4bacff161UL,0x4b082b2acUL,0x4b6b98c17UL,0x4f04915e5UL,0x4fc3f6893UL,0x4ee9ed1b2UL,0x4e8a5ef09UL,0x4e2e8acc4UL,0x4e4d3927fUL,0x4c7abde86UL,0x4c190e03dUL,0x4cbdda3f0UL,0x4cde69d4bUL,0x4df47246aUL,0x4d97c1ad1UL,0x4d331591cUL,0x6c1f6e4ceUL,0x6c7cdda75UL,0x6cbbba703UL,0x6d91a1e22UL,0x6df212099UL,0x6d56c6354UL,0x6f6142fadUL,0x6fc596c60UL,0x6e8c3ebfaUL,0x6eef8d541UL,0x6e28ea837UL,0x6a2450f7eUL,0x6a47e31c5UL,0x6ae337208UL,0x6baa9f592UL,0x6b6df88e4UL,0x6b0e4b65fUL,0x6939cfaa6UL,0x69fea87d0UL,0x699d1b96bUL,0x68b70004aUL,0x68d4b3ef1UL,0x6813d4387UL,0x6069133aeUL,0x60ae74ed8UL,0x60cdc7063UL,0x61846f7f9UL,0x6120bb434UL,0x614308a8fUL,0x63748c676UL,0x63173f8cdUL,0x63d0585bbUL,0x62fa43c9aUL,0x6299f0221UL,0x66522d81eUL,0x66319e6a5UL,0x66954a568UL,0x66f6f9bd3UL,0x67bf51c49UL,0x671b85f84UL,0x67783613fUL,0x654fb2dc6UL,0x64c17d72aUL,0x64a2ce991UL,0x64061aa5cUL,0x6465a94e7UL,0x74f394a0eUL,0x7490274b5UL,0x7434f3778UL,0x77ee0bfd6UL,0x778db816dUL,0x774adfc1bUL,0x7660c453aUL,0x760377b81UL,0x720fcdcc8UL,0x726c7e273UL,0x734665b52UL,0x7325d65e9UL,0x738102624UL,0x71d535466UL,0x711252910UL,0x7171e17abUL,0x705bfae8aUL,0x70ff2ed47UL,0x78213dea3UL,0x790b26782UL,0x79cc41af4UL,0x7b98768b6UL,0x7b5f115c0UL,0x7b3ca2b7bUL,0x7a16b925aUL,0x7a750ace1UL,0x7ad1def2cUL,0x7ab26d197UL,0x7ebed76deUL,0x7edd64865UL,0x7e1a03513UL,0x7f3018c32UL,0x7f53ab289UL,0x7ff77f144UL,0x7f94ccfffUL,0x7da348306UL,0x7d079c0cbUL,0x7c8953a27UL,0xffeefe288UL,0xfe6031864UL,0xf4ea159c2UL,0xf61af684dUL,0xf730ed16cUL,0xf0851c030UL,0xe6ef7881fUL,0xe8cd32d3dUL,0xc9262ed99UL,0xc47a483d8UL,0xc222c56d3UL,0xc36b6d149UL,0xc3ac0ac3fUL,0xc1f83de7dUL,0xc13f5a30bUL,0xc076f2491UL,0xd39ee311bUL,0xd61c96cbeUL,0xd6b842f73UL,0xd7f1ea8e9UL,0xd7553eb24UL,0xd42b12047UL,0xdc3266ed5UL,0xdddf1aa82UL,0x9e0922bcaUL,0x9eadf6807UL,0x97fd2a10fUL,0x948306a6cUL,0x91a5a7404UL,0x9336f7b30UL,0x927f5fcaaUL,0x92db8bf67UL,0x822e05f35UL,0x828ad1cf8UL,0x859bf4e69UL,0x8708a415dUL,0x86866bbb1UL,0x86410c6c7UL,0x8e9f1f523UL,0x8fd6b72b9UL,0x8ccb28761UL,0xabbfdefb8UL,0xaaf676822UL,0xad84e0408UL,0xac699c05fUL,0xaefaccf6bUL,0xaf17b0b3cUL,0xaf7403587UL,0xa6476c234UL,0xa470e8ecdUL,0xa4b78f3bbUL,0xa53940957UL,0xa07c52984UL,0xa01fe173fUL,0xa22865bc6UL,0xa3c519f91UL,0xb21a8c6e2UL,0xb2be5852fUL,0xb1a3c70f7UL,0xb798f9b47UL,0xbf818d5d5UL,0xbe0f42f39UL,0xbcffa1eb6UL,0xbd12ddae1UL,0xb97dd4313UL,0x3d68ef796UL,0x3daf88ae0UL,0x382dfd745UL,0x3abead871UL,0x35719b904UL,0x3725acb46UL,0x26fa39235UL,0x263d5ef43UL,0x27d022b14UL,0x2065d3a48UL,0x212c7bdd2UL,0x214fc8369UL,0x21eb1c0a4UL,0x2b028bfb9UL,0x2bc5ec2cfUL,0x2991db08dUL,0x28bbc09acUL,0x2c701d393UL,0x2d39b5409UL,0x2d9d617c4UL,0x2dfed297fUL,0x2e242a1d1UL,0xfcf36175UL,0xc15ce9dbUL,0xd5c66e41UL,0xdf8b2d8cUL,0x997bb47eUL,0xa8a241a6UL,0x23784cf9UL,0x2f0e318fUL,0x5e1c631eUL,0x58275da5UL,0x4cbdda3fUL,0x6588d50bUL,0x178718c78UL,0x166a6482fUL,0x145de04d6UL,0x149a879a0UL,0x10f58e052UL,0x10515a39fUL,0x138ba2b31UL,0x19c6e17e1UL,0x19623542cUL,0x1d0d3cddeUL,0x1d6e8f365UL,0x1e73106bdUL,0x5dc69b94eUL,0x5d01fc438UL,0x5c48543a2UL,0x5c8f33ed4UL,0x5cec8006fUL,0x5eb8b722dUL,0x5f55cb67aUL,0x5f36788c1UL,0x5bfda52feUL,0x5b3ac2f88UL,0x58275da50UL,0x5844ee4ebUL,0x590d46371UL,0x517781358UL,0x505d9aa79UL,0x52ad79bf6UL,0x534005fa1UL,0x578bd859eUL,0x5666a41c9UL,0x54329338bUL,0x55dfef7dcUL,0x452a6178eUL,0x4549d2935UL,0x44c71d3d9UL,0x46544dcedUL,0x46932a19bUL,0x47b9318baUL,0x471de5b77UL,0x43d638148UL,0x43b58bff3UL,0x42fc23869UL,0x400cc09e6UL,0x406f7375dUL,0x4126db0c7UL,0x48d2d3a02UL,0x4876079cfUL,0x4f6722b5eUL,0x4fa045628UL,0x4d50a67a7UL,0x6f02f1116UL,0x6fa6252dbUL,0x6e4b5968cUL,0x6a8084cb3UL,0x695a7c41dUL,0x61e7dc942UL,0x623d241ecUL,0x625e97f57UL,0x67dce22f2UL,0x65eb66e0bUL,0x7457409c3UL,0x751ee8e59UL,0x75d98f32fUL,0x77296c2a0UL,0x76c4106f7UL,0x72c8aa1beUL,0x71b686addUL,0x703849031UL,0x78e65a3d5UL,0x78428e018UL,0x796895939UL,0x79aff244fUL,0x7c2d879eaUL,0x7ceae049cUL,0xc3cfb9284UL,0xdb40f02ffUL,0x8b7ed963dUL,0xab78b92ceUL,0xf0851c03UL,0xcb11aa16UL,0xd9b01337UL,0x18ecfaecUL,0x46f099f2UL,0x1b360266eUL,0x5ad7bebdfUL,0x551888aaaUL,0x63b3ebb00UL,0x75ba3cd94UL,0x98f57bd0cUL,0xf912a744eUL}; + fromVector(codes,d._code_id); + d._nbits=36; + d._tau=0; + d._type=ARTAG; + d._name="ARTAG"; + + }break; + case ARTOOLKITPLUS:{ + vector codes={0x6dc269c27UL,0x6d4229e26UL,0x6cc2e9825UL,0x6c42a9a24UL,0x6fc369423UL,0x6f4329622UL,0x6ec3e9021UL,0x6e43a9220UL,0x69c068c2fUL,0x694028e2eUL,0x68c0e882dUL,0x6840a8a2cUL,0x6bc16842bUL,0x6b412862aUL,0x6ac1e8029UL,0x6a41a8228UL,0x65c66bc37UL,0x65462be36UL,0x64c6eb835UL,0x6446aba34UL,0x67c76b433UL,0x67472b632UL,0x66c7eb031UL,0x6647ab230UL,0x61c46ac3fUL,0x61442ae3eUL,0x60c4ea83dUL,0x6044aaa3cUL,0x63c56a43bUL,0x63452a63aUL,0x62c5ea039UL,0x6245aa238UL,0x7dca6dc07UL,0x7d4a2de06UL,0x7ccaed805UL,0x7c4aada04UL,0x7fcb6d403UL,0x7f4b2d602UL,0x7ecbed001UL,0x7e4bad200UL,0x79c86cc0fUL,0x79482ce0eUL,0x78c8ec80dUL,0x7848aca0cUL,0x7bc96c40bUL,0x7b492c60aUL,0x7ac9ec009UL,0x7a49ac208UL,0x75ce6fc17UL,0x754e2fe16UL,0x74ceef815UL,0x744eafa14UL,0x77cf6f413UL,0x774f2f612UL,0x76cfef011UL,0x764faf210UL,0x71cc6ec1fUL,0x714c2ee1eUL,0x70ccee81dUL,0x704caea1cUL,0x73cd6e41bUL,0x734d2e61aUL,0x72cdee019UL,0x724dae218UL,0x4dd261c67UL,0x4d5221e66UL,0x4cd2e1865UL,0x4c52a1a64UL,0x4fd361463UL,0x4f5321662UL,0x4ed3e1061UL,0x4e53a1260UL,0x49d060c6fUL,0x495020e6eUL,0x48d0e086dUL,0x4850a0a6cUL,0x4bd16046bUL,0x4b512066aUL,0x4ad1e0069UL,0x4a51a0268UL,0x45d663c77UL,0x455623e76UL,0x44d6e3875UL,0x4456a3a74UL,0x47d763473UL,0x475723672UL,0x46d7e3071UL,0x4657a3270UL,0x41d462c7fUL,0x415422e7eUL,0x40d4e287dUL,0x4054a2a7cUL,0x43d56247bUL,0x43552267aUL,0x42d5e2079UL,0x4255a2278UL,0x5dda65c47UL,0x5d5a25e46UL,0x5cdae5845UL,0x5c5aa5a44UL,0x5fdb65443UL,0x5f5b25642UL,0x5edbe5041UL,0x5e5ba5240UL,0x59d864c4fUL,0x595824e4eUL,0x58d8e484dUL,0x5858a4a4cUL,0x5bd96444bUL,0x5b592464aUL,0x5ad9e4049UL,0x5a59a4248UL,0x55de67c57UL,0x555e27e56UL,0x54dee7855UL,0x545ea7a54UL,0x57df67453UL,0x575f27652UL,0x56dfe7051UL,0x565fa7250UL,0x51dc66c5fUL,0x515c26e5eUL,0x50dce685dUL,0x505ca6a5cUL,0x53dd6645bUL,0x535d2665aUL,0x52dde6059UL,0x525da6258UL,0x2de279ca7UL,0x2d6239ea6UL,0x2ce2f98a5UL,0x2c62b9aa4UL,0x2fe3794a3UL,0x2f63396a2UL,0x2ee3f90a1UL,0x2e63b92a0UL,0x29e078cafUL,0x296038eaeUL,0x28e0f88adUL,0x2860b8aacUL,0x2be1784abUL,0x2b61386aaUL,0x2ae1f80a9UL,0x2a61b82a8UL,0x25e67bcb7UL,0x25663beb6UL,0x24e6fb8b5UL,0x2466bbab4UL,0x27e77b4b3UL,0x27673b6b2UL,0x26e7fb0b1UL,0x2667bb2b0UL,0x21e47acbfUL,0x21643aebeUL,0x20e4fa8bdUL,0x2064baabcUL,0x23e57a4bbUL,0x23653a6baUL,0x22e5fa0b9UL,0x2265ba2b8UL,0x3dea7dc87UL,0x3d6a3de86UL,0x3ceafd885UL,0x3c6abda84UL,0x3feb7d483UL,0x3f6b3d682UL,0x3eebfd081UL,0x3e6bbd280UL,0x39e87cc8fUL,0x39683ce8eUL,0x38e8fc88dUL,0x3868bca8cUL,0x3be97c48bUL,0x3b693c68aUL,0x3ae9fc089UL,0x3a69bc288UL,0x35ee7fc97UL,0x356e3fe96UL,0x34eeff895UL,0x346ebfa94UL,0x37ef7f493UL,0x376f3f692UL,0x36efff091UL,0x366fbf290UL,0x31ec7ec9fUL,0x316c3ee9eUL,0x30ecfe89dUL,0x306cbea9cUL,0x33ed7e49bUL,0x336d3e69aUL,0x32edfe099UL,0x326dbe298UL,0xdf271ce7UL,0xd7231ee6UL,0xcf2f18e5UL,0xc72b1ae4UL,0xff3714e3UL,0xf73316e2UL,0xef3f10e1UL,0xe73b12e0UL,0x9f070cefUL,0x97030eeeUL,0x8f0f08edUL,0x870b0aecUL,0xbf1704ebUL,0xb71306eaUL,0xaf1f00e9UL,0xa71b02e8UL,0x5f673cf7UL,0x57633ef6UL,0x4f6f38f5UL,0x476b3af4UL,0x7f7734f3UL,0x777336f2UL,0x6f7f30f1UL,0x677b32f0UL,0x1f472cffUL,0x17432efeUL,0xf4f28fdUL,0x74b2afcUL,0x3f5724fbUL,0x375326faUL,0x2f5f20f9UL,0x275b22f8UL,0x1dfa75cc7UL,0x1d7a35ec6UL,0x1cfaf58c5UL,0x1c7ab5ac4UL,0x1ffb754c3UL,0x1f7b356c2UL,0x1efbf50c1UL,0x1e7bb52c0UL,0x19f874ccfUL,0x197834eceUL,0x18f8f48cdUL,0x1878b4accUL,0x1bf9744cbUL,0x1b79346caUL,0x1af9f40c9UL,0x1a79b42c8UL,0x15fe77cd7UL,0x157e37ed6UL,0x14fef78d5UL,0x147eb7ad4UL,0x17ff774d3UL,0x177f376d2UL,0x16fff70d1UL,0x167fb72d0UL,0x11fc76cdfUL,0x117c36edeUL,0x10fcf68ddUL,0x107cb6adcUL,0x13fd764dbUL,0x137d366daUL,0x12fdf60d9UL,0x127db62d8UL,0xed8249d27UL,0xed0209f26UL,0xec82c9925UL,0xec0289b24UL,0xef8349523UL,0xef0309722UL,0xee83c9121UL,0xee0389320UL,0xe98048d2fUL,0xe90008f2eUL,0xe880c892dUL,0xe80088b2cUL,0xeb814852bUL,0xeb010872aUL,0xea81c8129UL,0xea0188328UL,0xe5864bd37UL,0xe5060bf36UL,0xe486cb935UL,0xe4068bb34UL,0xe7874b533UL,0xe7070b732UL,0xe687cb131UL,0xe6078b330UL,0xe1844ad3fUL,0xe1040af3eUL,0xe084ca93dUL,0xe0048ab3cUL,0xe3854a53bUL,0xe3050a73aUL,0xe285ca139UL,0xe2058a338UL,0xfd8a4dd07UL,0xfd0a0df06UL,0xfc8acd905UL,0xfc0a8db04UL,0xff8b4d503UL,0xff0b0d702UL,0xfe8bcd101UL,0xfe0b8d300UL,0xf9884cd0fUL,0xf9080cf0eUL,0xf888cc90dUL,0xf8088cb0cUL,0xfb894c50bUL,0xfb090c70aUL,0xfa89cc109UL,0xfa098c308UL,0xf58e4fd17UL,0xf50e0ff16UL,0xf48ecf915UL,0xf40e8fb14UL,0xf78f4f513UL,0xf70f0f712UL,0xf68fcf111UL,0xf60f8f310UL,0xf18c4ed1fUL,0xf10c0ef1eUL,0xf08cce91dUL,0xf00c8eb1cUL,0xf38d4e51bUL,0xf30d0e71aUL,0xf28dce119UL,0xf20d8e318UL,0xcd9241d67UL,0xcd1201f66UL,0xcc92c1965UL,0xcc1281b64UL,0xcf9341563UL,0xcf1301762UL,0xce93c1161UL,0xce1381360UL,0xc99040d6fUL,0xc91000f6eUL,0xc890c096dUL,0xc81080b6cUL,0xcb914056bUL,0xcb110076aUL,0xca91c0169UL,0xca1180368UL,0xc59643d77UL,0xc51603f76UL,0xc496c3975UL,0xc41683b74UL,0xc79743573UL,0xc71703772UL,0xc697c3171UL,0xc61783370UL,0xc19442d7fUL,0xc11402f7eUL,0xc094c297dUL,0xc01482b7cUL,0xc3954257bUL,0xc3150277aUL,0xc295c2179UL,0xc21582378UL,0xdd9a45d47UL,0xdd1a05f46UL,0xdc9ac5945UL,0xdc1a85b44UL,0xdf9b45543UL,0xdf1b05742UL,0xde9bc5141UL,0xde1b85340UL,0xd99844d4fUL,0xd91804f4eUL,0xd898c494dUL,0xd81884b4cUL,0xdb994454bUL,0xdb190474aUL,0xda99c4149UL,0xda1984348UL,0xd59e47d57UL,0xd51e07f56UL,0xd49ec7955UL,0xd41e87b54UL,0xd79f47553UL,0xd71f07752UL,0xd69fc7151UL,0xd61f87350UL,0xd19c46d5fUL,0xd11c06f5eUL,0xd09cc695dUL,0xd01c86b5cUL,0xd39d4655bUL,0xd31d0675aUL,0xd29dc6159UL,0xd21d86358UL,0xada259da7UL,0xad2219fa6UL,0xaca2d99a5UL,0xac2299ba4UL,0xafa3595a3UL,0xaf23197a2UL,0xaea3d91a1UL,0xae23993a0UL,0xa9a058dafUL,0xa92018faeUL,0xa8a0d89adUL,0xa82098bacUL,0xaba1585abUL,0xab21187aaUL,0xaaa1d81a9UL,0xaa21983a8UL,0xa5a65bdb7UL,0xa5261bfb6UL,0xa4a6db9b5UL,0xa4269bbb4UL,0xa7a75b5b3UL,0xa7271b7b2UL,0xa6a7db1b1UL,0xa6279b3b0UL,0xa1a45adbfUL,0xa1241afbeUL,0xa0a4da9bdUL,0xa0249abbcUL,0xa3a55a5bbUL,0xa3251a7baUL,0xa2a5da1b9UL,0xa2259a3b8UL,0xbdaa5dd87UL,0xbd2a1df86UL,0xbcaadd985UL,0xbc2a9db84UL,0xbfab5d583UL,0xbf2b1d782UL,0xbeabdd181UL,0xbe2b9d380UL,0xb9a85cd8fUL,0xb9281cf8eUL,0xb8a8dc98dUL,0xb8289cb8cUL,0xbba95c58bUL,0xbb291c78aUL,0xbaa9dc189UL,0xba299c388UL,0xb5ae5fd97UL,0xb52e1ff96UL,0xb4aedf995UL,0xb42e9fb94UL,0xb7af5f593UL,0xb72f1f792UL,0xb6afdf191UL,0xb62f9f390UL,0xb1ac5ed9fUL,0xb12c1ef9eUL,0xb0acde99dUL,0xb02c9eb9cUL,0xb3ad5e59bUL,0xb32d1e79aUL,0xb2adde199UL,0xb22d9e398UL,0x8db251de7UL,0x8d3211fe6UL,0x8cb2d19e5UL,0x8c3291be4UL,0x8fb3515e3UL,0x8f33117e2UL,0x8eb3d11e1UL,0x8e33913e0UL,0x89b050defUL,0x893010feeUL,0x88b0d09edUL,0x883090becUL,0x8bb1505ebUL,0x8b31107eaUL,0x8ab1d01e9UL,0x8a31903e8UL,0x85b653df7UL,0x853613ff6UL,0x84b6d39f5UL,0x843693bf4UL,0x87b7535f3UL,0x8737137f2UL,0x86b7d31f1UL,0x8637933f0UL,0x81b452dffUL,0x813412ffeUL,0x80b4d29fdUL,0x803492bfcUL,0x83b5525fbUL,0x8335127faUL,0x82b5d21f9UL,0x8235923f8UL,0x9dba55dc7UL,0x9d3a15fc6UL,0x9cbad59c5UL,0x9c3a95bc4UL,0x9fbb555c3UL,0x9f3b157c2UL,0x9ebbd51c1UL,0x9e3b953c0UL,0x99b854dcfUL,0x993814fceUL,0x98b8d49cdUL,0x983894bccUL,0x9bb9545cbUL,0x9b39147caUL,0x9ab9d41c9UL,0x9a39943c8UL,0x95be57dd7UL,0x953e17fd6UL,0x94bed79d5UL,0x943e97bd4UL,0x97bf575d3UL,0x973f177d2UL,0x96bfd71d1UL,0x963f973d0UL,0x91bc56ddfUL,0x913c16fdeUL,0x90bcd69ddUL,0x903c96bdcUL,0x93bd565dbUL,0x933d167daUL,0x92bdd61d9UL,0x923d963d8UL}; + fromVector(codes,d._code_id); + d._nbits=36; + d._tau=4;// + d._type=ARTOOLKITPLUS; + d._name="ARTOOLKITPLUS"; + + }break; + case ARTOOLKITPLUSBCH:{ + vector codes={0x8f80b8750UL,0x8f9d0a027UL,0x8fa66eec9UL,0x8fbbdc9beUL,0x8fcd15462UL,0x8fd0a7315UL,0x8febc3dfbUL,0x8ff671a8cUL,0x8f0650643UL,0x8f1be2134UL,0x8f2086fdaUL,0x8f3d348adUL,0x8f4bfd571UL,0x8f564f206UL,0x8f6d2bce8UL,0x8f7099b9fUL,0x8e8d68576UL,0x8e90da201UL,0x8eabbecefUL,0x8eb60cb98UL,0x8ec0c5644UL,0x8edd77133UL,0x8ee613fddUL,0x8efba18aaUL,0x8e0b80465UL,0x8e1632312UL,0x8e2d56dfcUL,0x8e30e4a8bUL,0x8e462d757UL,0x8e5b9f020UL,0x8e60fbeceUL,0x8e7d499b9UL,0x8d86aa46bUL,0x8d9b1831cUL,0x8da07cdf2UL,0x8dbdcea85UL,0x8dcb07759UL,0x8dd6b502eUL,0x8dedd1ec0UL,0x8df0639b7UL,0x8d0042578UL,0x8d1df020fUL,0x8d2694ce1UL,0x8d3b26b96UL,0x8d4def64aUL,0x8d505d13dUL,0x8d6b39fd3UL,0x8d768b8a4UL,0x8c8b7a64dUL,0x8c96c813aUL,0x8cadacfd4UL,0x8cb01e8a3UL,0x8cc6d757fUL,0x8cdb65208UL,0x8ce001ce6UL,0x8cfdb3b91UL,0x8c0d9275eUL,0x8c1020029UL,0x8c2b44ec7UL,0x8c36f69b0UL,0x8c403f46cUL,0x8c5d8d31bUL,0x8c66e9df5UL,0x8c7b5ba82UL,0x8b8c9c126UL,0x8b912e651UL,0x8baa4a8bfUL,0x8bb7f8fc8UL,0x8bc131214UL,0x8bdc83563UL,0x8be7e7b8dUL,0x8bfa55cfaUL,0x8b0a74035UL,0x8b17c6742UL,0x8b2ca29acUL,0x8b3110edbUL,0x8b47d9307UL,0x8b5a6b470UL,0x8b610fa9eUL,0x8b7cbdde9UL,0x8a814c300UL,0x8a9cfe477UL,0x8aa79aa99UL,0x8aba28deeUL,0x8acce1032UL,0x8ad153745UL,0x8aea379abUL,0x8af785edcUL,0x8a07a4213UL,0x8a1a16564UL,0x8a2172b8aUL,0x8a3cc0cfdUL,0x8a4a09121UL,0x8a57bb656UL,0x8a6cdf8b8UL,0x8a716dfcfUL,0x898a8e21dUL,0x89973c56aUL,0x89ac58b84UL,0x89b1eacf3UL,0x89c72312fUL,0x89da91658UL,0x89e1f58b6UL,0x89fc47fc1UL,0x890c6630eUL,0x8911d4479UL,0x892ab0a97UL,0x893702de0UL,0x8941cb03cUL,0x895c7974bUL,0x89671d9a5UL,0x897aafed2UL,0x88875e03bUL,0x889aec74cUL,0x88a1889a2UL,0x88bc3aed5UL,0x88caf3309UL,0x88d74147eUL,0x88ec25a90UL,0x88f197de7UL,0x8801b6128UL,0x881c0465fUL,0x8827608b1UL,0x883ad2fc6UL,0x884c1b21aUL,0x8851a956dUL,0x886acdb83UL,0x88777fcf4UL,0x878542ccbUL,0x8798f0bbcUL,0x87a394552UL,0x87be26225UL,0x87c8efff9UL,0x87d55d88eUL,0x87ee39660UL,0x87f38b117UL,0x8703aadd8UL,0x871e18aafUL,0x87257c441UL,0x8738ce336UL,0x874e07eeaUL,0x8753b599dUL,0x8768d1773UL,0x877563004UL,0x868892eedUL,0x86952099aUL,0x86ae44774UL,0x86b3f6003UL,0x86c53fddfUL,0x86d88daa8UL,0x86e3e9446UL,0x86fe5b331UL,0x860e7affeUL,0x8613c8889UL,0x8628ac667UL,0x86351e110UL,0x8643d7cccUL,0x865e65bbbUL,0x866501555UL,0x8678b3222UL,0x858350ff0UL,0x859ee2887UL,0x85a586669UL,0x85b83411eUL,0x85cefdcc2UL,0x85d34fbb5UL,0x85e82b55bUL,0x85f59922cUL,0x8505b8ee3UL,0x85180a994UL,0x85236e77aUL,0x853edc00dUL,0x854815dd1UL,0x8555a7aa6UL,0x856ec3448UL,0x85737133fUL,0x848e80dd6UL,0x849332aa1UL,0x84a85644fUL,0x84b5e4338UL,0x84c32dee4UL,0x84de9f993UL,0x84e5fb77dUL,0x84f84900aUL,0x840868cc5UL,0x8415dabb2UL,0x842ebe55cUL,0x84330c22bUL,0x8445c5ff7UL,0x845877880UL,0x84631366eUL,0x847ea1119UL,0x838966abdUL,0x8394d4dcaUL,0x83afb0324UL,0x83b202453UL,0x83c4cb98fUL,0x83d979ef8UL,0x83e21d016UL,0x83ffaf761UL,0x830f8ebaeUL,0x83123ccd9UL,0x832958237UL,0x8334ea540UL,0x83422389cUL,0x835f91febUL,0x8364f5105UL,0x837947672UL,0x8284b689bUL,0x829904fecUL,0x82a260102UL,0x82bfd2675UL,0x82c91bba9UL,0x82d4a9cdeUL,0x82efcd230UL,0x82f27f547UL,0x82025e988UL,0x821feceffUL,0x822488011UL,0x82393a766UL,0x824ff3abaUL,0x825241dcdUL,0x826925323UL,0x827497454UL,0x818f74986UL,0x8192c6ef1UL,0x81a9a201fUL,0x81b410768UL,0x81c2d9ab4UL,0x81df6bdc3UL,0x81e40f32dUL,0x81f9bd45aUL,0x81099c895UL,0x81142efe2UL,0x812f4a10cUL,0x8132f867bUL,0x814431ba7UL,0x815983cd0UL,0x8162e723eUL,0x817f55549UL,0x8082a4ba0UL,0x809f16cd7UL,0x80a472239UL,0x80b9c054eUL,0x80cf09892UL,0x80d2bbfe5UL,0x80e9df10bUL,0x80f46d67cUL,0x80044cab3UL,0x8019fedc4UL,0x80229a32aUL,0x803f2845dUL,0x8049e1981UL,0x805453ef6UL,0x806f37018UL,0x80728576fUL,0x9f8b4d066UL,0x9f96ff711UL,0x9fad9b9ffUL,0x9fb029e88UL,0x9fc6e0354UL,0x9fdb52423UL,0x9fe036acdUL,0x9ffd84dbaUL,0x9f0da5175UL,0x9f1017602UL,0x9f2b738ecUL,0x9f36c1f9bUL,0x9f4008247UL,0x9f5dba530UL,0x9f66debdeUL,0x9f7b6cca9UL,0x9e869d240UL,0x9e9b2f537UL,0x9ea04bbd9UL,0x9ebdf9caeUL,0x9ecb30172UL,0x9ed682605UL,0x9eede68ebUL,0x9ef054f9cUL,0x9e0075353UL,0x9e1dc7424UL,0x9e26a3acaUL,0x9e3b11dbdUL,0x9e4dd8061UL,0x9e506a716UL,0x9e6b0e9f8UL,0x9e76bce8fUL,0x9d8d5f35dUL,0x9d90ed42aUL,0x9dab89ac4UL,0x9db63bdb3UL,0x9dc0f206fUL,0x9ddd40718UL,0x9de6249f6UL,0x9dfb96e81UL,0x9d0bb724eUL,0x9d1605539UL,0x9d2d61bd7UL,0x9d30d3ca0UL,0x9d461a17cUL,0x9d5ba860bUL,0x9d60cc8e5UL,0x9d7d7ef92UL,0x9c808f17bUL,0x9c9d3d60cUL,0x9ca6598e2UL,0x9cbbebf95UL,0x9ccd22249UL,0x9cd09053eUL,0x9cebf4bd0UL,0x9cf646ca7UL,0x9c0667068UL,0x9c1bd571fUL,0x9c20b19f1UL,0x9c3d03e86UL,0x9c4bca35aUL,0x9c567842dUL,0x9c6d1cac3UL,0x9c70aedb4UL,0x9b8769610UL,0x9b9adb167UL,0x9ba1bff89UL,0x9bbc0d8feUL,0x9bcac4522UL,0x9bd776255UL,0x9bec12cbbUL,0x9bf1a0bccUL,0x9b0181703UL,0x9b1c33074UL,0x9b2757e9aUL,0x9b3ae59edUL,0x9b4c2c431UL,0x9b519e346UL,0x9b6afada8UL,0x9b7748adfUL,0x9a8ab9436UL,0x9a970b341UL,0x9aac6fdafUL,0x9ab1ddad8UL,0x9ac714704UL,0x9adaa6073UL,0x9ae1c2e9dUL,0x9afc709eaUL,0x9a0c51525UL,0x9a11e3252UL,0x9a2a87cbcUL,0x9a3735bcbUL,0x9a41fc617UL,0x9a5c4e160UL,0x9a672af8eUL,0x9a7a988f9UL,0x99817b52bUL,0x999cc925cUL,0x99a7adcb2UL,0x99ba1fbc5UL,0x99ccd6619UL,0x99d16416eUL,0x99ea00f80UL,0x99f7b28f7UL,0x990793438UL,0x991a2134fUL,0x992145da1UL,0x993cf7ad6UL,0x994a3e70aUL,0x99578c07dUL,0x996ce8e93UL,0x99715a9e4UL,0x988cab70dUL,0x98911907aUL,0x98aa7de94UL,0x98b7cf9e3UL,0x98c10643fUL,0x98dcb4348UL,0x98e7d0da6UL,0x98fa62ad1UL,0x980a4361eUL,0x9817f1169UL,0x982c95f87UL,0x9831278f0UL,0x9847ee52cUL,0x985a5c25bUL,0x986138cb5UL,0x987c8abc2UL,0x978eb7bfdUL,0x979305c8aUL,0x97a861264UL,0x97b5d3513UL,0x97c31a8cfUL,0x97dea8fb8UL,0x97e5cc156UL,0x97f87e621UL,0x97085faeeUL,0x9715edd99UL,0x972e89377UL,0x97333b400UL,0x9745f29dcUL,0x975840eabUL,0x976324045UL,0x977e96732UL,0x9683679dbUL,0x969ed5eacUL,0x96a5b1042UL,0x96b803735UL,0x96cecaae9UL,0x96d378d9eUL,0x96e81c370UL,0x96f5ae407UL,0x96058f8c8UL,0x96183dfbfUL,0x962359151UL,0x963eeb626UL,0x964822bfaUL,0x965590c8dUL,0x966ef4263UL,0x967346514UL,0x9588a58c6UL,0x959517fb1UL,0x95ae7315fUL,0x95b3c1628UL,0x95c508bf4UL,0x95d8bac83UL,0x95e3de26dUL,0x95fe6c51aUL,0x950e4d9d5UL,0x9513ffea2UL,0x95289b04cUL,0x95352973bUL,0x9543e0ae7UL,0x955e52d90UL,0x95653637eUL,0x957884409UL,0x948575ae0UL,0x9498c7d97UL,0x94a3a3379UL,0x94be1140eUL,0x94c8d89d2UL,0x94d56aea5UL,0x94ee0e04bUL,0x94f3bc73cUL,0x94039dbf3UL,0x941e2fc84UL,0x94254b26aUL,0x9438f951dUL,0x944e308c1UL,0x945382fb6UL,0x9468e6158UL,0x94755462fUL,0x938293d8bUL,0x939f21afcUL,0x93a445412UL,0x93b9f7365UL,0x93cf3eeb9UL,0x93d28c9ceUL,0x93e9e8720UL,0x93f45a057UL,0x93047bc98UL,0x9319c9befUL,0x9322ad501UL,0x933f1f276UL,0x9349d6faaUL,0x9354648ddUL,0x936f00633UL,0x9372b2144UL,0x928f43fadUL,0x9292f18daUL,0x92a995634UL,0x92b427143UL,0x92c2eec9fUL,0x92df5cbe8UL,0x92e438506UL,0x92f98a271UL,0x9209abebeUL,0x9214199c9UL,0x922f7d727UL,0x9232cf050UL,0x924406d8cUL,0x9259b4afbUL,0x9262d0415UL,0x927f62362UL,0x918481eb0UL,0x9199339c7UL,0x91a257729UL,0x91bfe505eUL,0x91c92cd82UL,0x91d49eaf5UL,0x91effa41bUL,0x91f24836cUL,0x910269fa3UL,0x911fdb8d4UL,0x9124bf63aUL,0x91390d14dUL,0x914fc4c91UL,0x915276be6UL,0x916912508UL,0x9174a027fUL,0x908951c96UL,0x9094e3be1UL,0x90af8750fUL,0x90b235278UL,0x90c4fcfa4UL,0x90d94e8d3UL,0x90e22a63dUL,0x90ff9814aUL,0x900fb9d85UL,0x90120baf2UL,0x90296f41cUL,0x9034dd36bUL,0x904214eb7UL,0x905fa69c0UL,0x9064c272eUL,0x907970059UL,0xaf8ae0e4bUL,0xaf975293cUL,0xafac367d2UL,0xafb1840a5UL,0xafc74dd79UL,0xafdaffa0eUL,0xafe19b4e0UL,0xaffc29397UL,0xaf0c08f58UL,0xaf11ba82fUL,0xaf2ade6c1UL,0xaf376c1b6UL,0xaf41a5c6aUL,0xaf5c17b1dUL,0xaf67735f3UL,0xaf7ac1284UL,0xae8730c6dUL,0xae9a82b1aUL,0xaea1e65f4UL,0xaebc54283UL,0xaeca9df5fUL,0xaed72f828UL,0xaeec4b6c6UL,0xaef1f91b1UL,0xae01d8d7eUL,0xae1c6aa09UL,0xae270e4e7UL,0xae3abc390UL,0xae4c75e4cUL,0xae51c793bUL,0xae6aa37d5UL,0xae77110a2UL,0xad8cf2d70UL,0xad9140a07UL,0xadaa244e9UL,0xadb79639eUL,0xadc15fe42UL,0xaddced935UL,0xade7897dbUL,0xadfa3b0acUL,0xad0a1ac63UL,0xad17a8b14UL,0xad2ccc5faUL,0xad317e28dUL,0xad47b7f51UL,0xad5a05826UL,0xad61616c8UL,0xad7cd31bfUL,0xac8122f56UL,0xac9c90821UL,0xaca7f46cfUL,0xacba461b8UL,0xaccc8fc64UL,0xacd13db13UL,0xacea595fdUL,0xacf7eb28aUL,0xac07cae45UL,0xac1a78932UL,0xac211c7dcUL,0xac3cae0abUL,0xac4a67d77UL,0xac57d5a00UL,0xac6cb14eeUL,0xac7103399UL,0xab86c483dUL,0xab9b76f4aUL,0xaba0121a4UL,0xabbda06d3UL,0xabcb69b0fUL,0xabd6dbc78UL,0xabedbf296UL,0xabf00d5e1UL,0xab002c92eUL,0xab1d9ee59UL,0xab26fa0b7UL,0xab3b487c0UL,0xab4d81a1cUL,0xab5033d6bUL,0xab6b57385UL,0xab76e54f2UL,0xaa8b14a1bUL,0xaa96a6d6cUL,0xaaadc2382UL,0xaab0704f5UL,0xaac6b9929UL,0xaadb0be5eUL,0xaae06f0b0UL,0xaafddd7c7UL,0xaa0dfcb08UL,0xaa104ec7fUL,0xaa2b2a291UL,0xaa36985e6UL,0xaa405183aUL,0xaa5de3f4dUL,0xaa66871a3UL,0xaa7b356d4UL,0xa980d6b06UL,0xa99d64c71UL,0xa9a60029fUL,0xa9bbb25e8UL,0xa9cd7b834UL,0xa9d0c9f43UL,0xa9ebad1adUL,0xa9f61f6daUL,0xa9063ea15UL,0xa91b8cd62UL,0xa920e838cUL,0xa93d5a4fbUL,0xa94b93927UL,0xa95621e50UL,0xa96d450beUL,0xa970f77c9UL,0xa88d06920UL,0xa890b4e57UL,0xa8abd00b9UL,0xa8b6627ceUL,0xa8c0aba12UL,0xa8dd19d65UL,0xa8e67d38bUL,0xa8fbcf4fcUL,0xa80bee833UL,0xa8165cf44UL,0xa82d381aaUL,0xa8308a6ddUL,0xa84643b01UL,0xa85bf1c76UL,0xa86095298UL,0xa87d275efUL,0xa78f1a5d0UL,0xa792a82a7UL,0xa7a9ccc49UL,0xa7b47eb3eUL,0xa7c2b76e2UL,0xa7df05195UL,0xa7e461f7bUL,0xa7f9d380cUL,0xa709f24c3UL,0xa714403b4UL,0xa72f24d5aUL,0xa73296a2dUL,0xa7445f7f1UL,0xa759ed086UL,0xa76289e68UL,0xa77f3b91fUL,0xa682ca7f6UL,0xa69f78081UL,0xa6a41ce6fUL,0xa6b9ae918UL,0xa6cf674c4UL,0xa6d2d53b3UL,0xa6e9b1d5dUL,0xa6f403a2aUL,0xa604226e5UL,0xa61990192UL,0xa622f4f7cUL,0xa63f4680bUL,0xa6498f5d7UL,0xa6543d2a0UL,0xa66f59c4eUL,0xa672ebb39UL,0xa589086ebUL,0xa594ba19cUL,0xa5afdef72UL,0xa5b26c805UL,0xa5c4a55d9UL,0xa5d9172aeUL,0xa5e273c40UL,0xa5ffc1b37UL,0xa50fe07f8UL,0xa5125208fUL,0xa52936e61UL,0xa53484916UL,0xa5424d4caUL,0xa55fff3bdUL,0xa5649bd53UL,0xa57929a24UL,0xa484d84cdUL,0xa4996a3baUL,0xa4a20ed54UL,0xa4bfbca23UL,0xa4c9757ffUL,0xa4d4c7088UL,0xa4efa3e66UL,0xa4f211911UL,0xa402305deUL,0xa41f822a9UL,0xa424e6c47UL,0xa43954b30UL,0xa44f9d6ecUL,0xa4522f19bUL,0xa4694bf75UL,0xa474f9802UL,0xa3833e3a6UL,0xa39e8c4d1UL,0xa3a5e8a3fUL,0xa3b85ad48UL,0xa3ce93094UL,0xa3d3217e3UL,0xa3e84590dUL,0xa3f5f7e7aUL,0xa305d62b5UL,0xa318645c2UL,0xa32300b2cUL,0xa33eb2c5bUL,0xa3487b187UL,0xa355c96f0UL,0xa36ead81eUL,0xa3731ff69UL,0xa28eee180UL,0xa2935c6f7UL,0xa2a838819UL,0xa2b58af6eUL,0xa2c3432b2UL,0xa2def15c5UL,0xa2e595b2bUL,0xa2f827c5cUL,0xa20806093UL,0xa215b47e4UL,0xa22ed090aUL,0xa23362e7dUL,0xa245ab3a1UL,0xa258194d6UL,0xa2637da38UL,0xa27ecfd4fUL,0xa1852c09dUL,0xa1989e7eaUL,0xa1a3fa904UL,0xa1be48e73UL,0xa1c8813afUL,0xa1d5334d8UL,0xa1ee57a36UL,0xa1f3e5d41UL,0xa103c418eUL,0xa11e766f9UL,0xa12512817UL,0xa138a0f60UL,0xa14e692bcUL,0xa153db5cbUL,0xa168bfb25UL,0xa1750dc52UL,0xa088fc2bbUL,0xa0954e5ccUL,0xa0ae2ab22UL,0xa0b398c55UL,0xa0c551189UL,0xa0d8e36feUL,0xa0e387810UL,0xa0fe35f67UL,0xa00e143a8UL,0xa013a64dfUL,0xa028c2a31UL,0xa03570d46UL,0xa043b909aUL,0xa05e0b7edUL,0xa0656f903UL,0xa078dde74UL,0xbf811597dUL,0xbf9ca7e0aUL,0xbfa7c30e4UL,0xbfba71793UL,0xbfccb8a4fUL,0xbfd10ad38UL,0xbfea6e3d6UL,0xbff7dc4a1UL,0xbf07fd86eUL,0xbf1a4ff19UL,0xbf212b1f7UL,0xbf3c99680UL,0xbf4a50b5cUL,0xbf57e2c2bUL,0xbf6c862c5UL,0xbf71345b2UL,0xbe8cc5b5bUL,0xbe9177c2cUL,0xbeaa132c2UL,0xbeb7a15b5UL,0xbec168869UL,0xbedcdaf1eUL,0xbee7be1f0UL,0xbefa0c687UL,0xbe0a2da48UL,0xbe179fd3fUL,0xbe2cfb3d1UL,0xbe31494a6UL,0xbe478097aUL,0xbe5a32e0dUL,0xbe61560e3UL,0xbe7ce4794UL,0xbd8707a46UL,0xbd9ab5d31UL,0xbda1d13dfUL,0xbdbc634a8UL,0xbdcaaa974UL,0xbdd718e03UL,0xbdec7c0edUL,0xbdf1ce79aUL,0xbd01efb55UL,0xbd1c5dc22UL,0xbd27392ccUL,0xbd3a8b5bbUL,0xbd4c42867UL,0xbd51f0f10UL,0xbd6a941feUL,0xbd7726689UL,0xbc8ad7860UL,0xbc9765f17UL,0xbcac011f9UL,0xbcb1b368eUL,0xbcc77ab52UL,0xbcdac8c25UL,0xbce1ac2cbUL,0xbcfc1e5bcUL,0xbc0c3f973UL,0xbc118de04UL,0xbc2ae90eaUL,0xbc375b79dUL,0xbc4192a41UL,0xbc5c20d36UL,0xbc67443d8UL,0xbc7af64afUL,0xbb8d31f0bUL,0xbb908387cUL,0xbbabe7692UL,0xbbb6551e5UL,0xbbc09cc39UL,0xbbdd2eb4eUL,0xbbe64a5a0UL,0xbbfbf82d7UL,0xbb0bd9e18UL,0xbb166b96fUL,0xbb2d0f781UL,0xbb30bd0f6UL,0xbb4674d2aUL,0xbb5bc6a5dUL,0xbb60a24b3UL,0xbb7d103c4UL,0xba80e1d2dUL,0xba9d53a5aUL,0xbaa6374b4UL,0xbabb853c3UL,0xbacd4ce1fUL,0xbad0fe968UL,0xbaeb9a786UL,0xbaf6280f1UL,0xba0609c3eUL,0xba1bbbb49UL,0xba20df5a7UL,0xba3d6d2d0UL,0xba4ba4f0cUL,0xba561687bUL,0xba6d72695UL,0xba70c01e2UL,0xb98b23c30UL,0xb99691b47UL,0xb9adf55a9UL,0xb9b0472deUL,0xb9c68ef02UL,0xb9db3c875UL,0xb9e05869bUL,0xb9fdea1ecUL,0xb90dcbd23UL,0xb91079a54UL,0xb92b1d4baUL,0xb936af3cdUL,0xb94066e11UL,0xb95dd4966UL,0xb966b0788UL,0xb97b020ffUL,0xb886f3e16UL,0xb89b41961UL,0xb8a02578fUL,0xb8bd970f8UL,0xb8cb5ed24UL,0xb8d6eca53UL,0xb8ed884bdUL,0xb8f03a3caUL,0xb8001bf05UL,0xb81da9872UL,0xb826cd69cUL,0xb83b7f1ebUL,0xb84db6c37UL,0xb85004b40UL,0xb86b605aeUL,0xb876d22d9UL,0xb784ef2e6UL,0xb7995d591UL,0xb7a239b7fUL,0xb7bf8bc08UL,0xb7c9421d4UL,0xb7d4f06a3UL,0xb7ef9484dUL,0xb7f226f3aUL,0xb702073f5UL,0xb71fb5482UL,0xb724d1a6cUL,0xb73963d1bUL,0xb74faa0c7UL,0xb752187b0UL,0xb7697c95eUL,0xb774cee29UL,0xb6893f0c0UL,0xb6948d7b7UL,0xb6afe9959UL,0xb6b25be2eUL,0xb6c4923f2UL,0xb6d920485UL,0xb6e244a6bUL,0xb6fff6d1cUL,0xb60fd71d3UL,0xb612656a4UL,0xb6290184aUL,0xb634b3f3dUL,0xb6427a2e1UL,0xb65fc8596UL,0xb664acb78UL,0xb6791ec0fUL,0xb582fd1ddUL,0xb59f4f6aaUL,0xb5a42b844UL,0xb5b999f33UL,0xb5cf502efUL,0xb5d2e2598UL,0xb5e986b76UL,0xb5f434c01UL,0xb504150ceUL,0xb519a77b9UL,0xb522c3957UL,0xb53f71e20UL,0xb549b83fcUL,0xb5540a48bUL,0xb56f6ea65UL,0xb572dcd12UL,0xb48f2d3fbUL,0xb4929f48cUL,0xb4a9fba62UL,0xb4b449d15UL,0xb4c2800c9UL,0xb4df327beUL,0xb4e456950UL,0xb4f9e4e27UL,0xb409c52e8UL,0xb4147759fUL,0xb42f13b71UL,0xb432a1c06UL,0xb444681daUL,0xb459da6adUL,0xb462be843UL,0xb47f0cf34UL,0xb388cb490UL,0xb395793e7UL,0xb3ae1dd09UL,0xb3b3afa7eUL,0xb3c5667a2UL,0xb3d8d40d5UL,0xb3e3b0e3bUL,0xb3fe0294cUL,0xb30e23583UL,0xb313912f4UL,0xb328f5c1aUL,0xb33547b6dUL,0xb3438e6b1UL,0xb35e3c1c6UL,0xb36558f28UL,0xb378ea85fUL,0xb2851b6b6UL,0xb298a91c1UL,0xb2a3cdf2fUL,0xb2be7f858UL,0xb2c8b6584UL,0xb2d5042f3UL,0xb2ee60c1dUL,0xb2f3d2b6aUL,0xb203f37a5UL,0xb21e410d2UL,0xb22525e3cUL,0xb2389794bUL,0xb24e5e497UL,0xb253ec3e0UL,0xb26888d0eUL,0xb2753aa79UL,0xb18ed97abUL,0xb1936b0dcUL,0xb1a80fe32UL,0xb1b5bd945UL,0xb1c374499UL,0xb1dec63eeUL,0xb1e5a2d00UL,0xb1f810a77UL,0xb108316b8UL,0xb115831cfUL,0xb12ee7f21UL,0xb13355856UL,0xb1459c58aUL,0xb1582e2fdUL,0xb1634ac13UL,0xb17ef8b64UL,0xb0830958dUL,0xb09ebb2faUL,0xb0a5dfc14UL,0xb0b86db63UL,0xb0cea46bfUL,0xb0d3161c8UL,0xb0e872f26UL,0xb0f5c0851UL,0xb005e149eUL,0xb018533e9UL,0xb02337d07UL,0xb03e85a70UL,0xb0484c7acUL,0xb055fe0dbUL,0xb06e9ae35UL,0xb07328942UL,0xcf89bb211UL,0xcf9409566UL,0xcfaf6db88UL,0xcfb2dfcffUL,0xcfc416123UL,0xcfd9a4654UL,0xcfe2c08baUL,0xcfff72fcdUL,0xcf0f53302UL,0xcf12e1475UL,0xcf2985a9bUL,0xcf3437decUL,0xcf42fe030UL,0xcf5f4c747UL,0xcf64289a9UL,0xcf799aedeUL,0xce846b037UL,0xce99d9740UL,0xcea2bd9aeUL,0xcebf0fed9UL,0xcec9c6305UL,0xced474472UL,0xceef10a9cUL,0xcef2a2debUL,0xce0283124UL,0xce1f31653UL,0xce24558bdUL,0xce39e7fcaUL,0xce4f2e216UL,0xce529c561UL,0xce69f8b8fUL,0xce744acf8UL,0xcd8fa912aUL,0xcd921b65dUL,0xcda97f8b3UL,0xcdb4cdfc4UL,0xcdc204218UL,0xcddfb656fUL,0xcde4d2b81UL,0xcdf960cf6UL,0xcd0941039UL,0xcd14f374eUL,0xcd2f979a0UL,0xcd3225ed7UL,0xcd44ec30bUL,0xcd595e47cUL,0xcd623aa92UL,0xcd7f88de5UL,0xcc827930cUL,0xcc9fcb47bUL,0xcca4afa95UL,0xccb91dde2UL,0xcccfd403eUL,0xccd266749UL,0xcce9029a7UL,0xccf4b0ed0UL,0xcc049121fUL,0xcc1923568UL,0xcc2247b86UL,0xcc3ff5cf1UL,0xcc493c12dUL,0xcc548e65aUL,0xcc6fea8b4UL,0xcc7258fc3UL,0xcb859f467UL,0xcb982d310UL,0xcba349dfeUL,0xcbbefba89UL,0xcbc832755UL,0xcbd580022UL,0xcbeee4eccUL,0xcbf3569bbUL,0xcb0377574UL,0xcb1ec5203UL,0xcb25a1cedUL,0xcb3813b9aUL,0xcb4eda646UL,0xcb5368131UL,0xcb680cfdfUL,0xcb75be8a8UL,0xca884f641UL,0xca95fd136UL,0xcaae99fd8UL,0xcab32b8afUL,0xcac5e2573UL,0xcad850204UL,0xcae334ceaUL,0xcafe86b9dUL,0xca0ea7752UL,0xca1315025UL,0xca2871ecbUL,0xca35c39bcUL,0xca430a460UL,0xca5eb8317UL,0xca65dcdf9UL,0xca786ea8eUL,0xc9838d75cUL,0xc99e3f02bUL,0xc9a55bec5UL,0xc9b8e99b2UL,0xc9ce2046eUL,0xc9d392319UL,0xc9e8f6df7UL,0xc9f544a80UL,0xc9056564fUL,0xc918d7138UL,0xc923b3fd6UL,0xc93e018a1UL,0xc948c857dUL,0xc9557a20aUL,0xc96e1ece4UL,0xc973acb93UL,0xc88e5d57aUL,0xc893ef20dUL,0xc8a88bce3UL,0xc8b539b94UL,0xc8c3f0648UL,0xc8de4213fUL,0xc8e526fd1UL,0xc8f8948a6UL,0xc808b5469UL,0xc8150731eUL,0xc82e63df0UL,0xc833d1a87UL,0xc8451875bUL,0xc858aa02cUL,0xc863ceec2UL,0xc87e7c9b5UL,0xc78c4198aUL,0xc791f3efdUL,0xc7aa97013UL,0xc7b725764UL,0xc7c1ecab8UL,0xc7dc5edcfUL,0xc7e73a321UL,0xc7fa88456UL,0xc70aa9899UL,0xc7171bfeeUL,0xc72c7f100UL,0xc731cd677UL,0xc74704babUL,0xc75ab6cdcUL,0xc761d2232UL,0xc77c60545UL,0xc68191bacUL,0xc69c23cdbUL,0xc6a747235UL,0xc6baf5542UL,0xc6cc3c89eUL,0xc6d18efe9UL,0xc6eaea107UL,0xc6f758670UL,0xc60779abfUL,0xc61acbdc8UL,0xc621af326UL,0xc63c1d451UL,0xc64ad498dUL,0xc65766efaUL,0xc66c02014UL,0xc671b0763UL,0xc58a53ab1UL,0xc597e1dc6UL,0xc5ac85328UL,0xc5b13745fUL,0xc5c7fe983UL,0xc5da4cef4UL,0xc5e12801aUL,0xc5fc9a76dUL,0xc50cbbba2UL,0xc51109cd5UL,0xc52a6d23bUL,0xc537df54cUL,0xc54116890UL,0xc55ca4fe7UL,0xc567c0109UL,0xc57a7267eUL,0xc48783897UL,0xc49a31fe0UL,0xc4a15510eUL,0xc4bce7679UL,0xc4ca2eba5UL,0xc4d79ccd2UL,0xc4ecf823cUL,0xc4f14a54bUL,0xc4016b984UL,0xc41cd9ef3UL,0xc427bd01dUL,0xc43a0f76aUL,0xc44cc6ab6UL,0xc45174dc1UL,0xc46a1032fUL,0xc477a2458UL,0xc38065ffcUL,0xc39dd788bUL,0xc3a6b3665UL,0xc3bb01112UL,0xc3cdc8cceUL,0xc3d07abb9UL,0xc3eb1e557UL,0xc3f6ac220UL,0xc3068deefUL,0xc31b3f998UL,0xc3205b776UL,0xc33de9001UL,0xc34b20dddUL,0xc35692aaaUL,0xc36df6444UL,0xc37044333UL,0xc28db5ddaUL,0xc29007aadUL,0xc2ab63443UL,0xc2b6d1334UL,0xc2c018ee8UL,0xc2ddaa99fUL,0xc2e6ce771UL,0xc2fb7c006UL,0xc20b5dcc9UL,0xc216efbbeUL,0xc22d8b550UL,0xc23039227UL,0xc246f0ffbUL,0xc25b4288cUL,0xc26026662UL,0xc27d94115UL,0xc18677cc7UL,0xc19bc5bb0UL,0xc1a0a155eUL,0xc1bd13229UL,0xc1cbdaff5UL,0xc1d668882UL,0xc1ed0c66cUL,0xc1f0be11bUL,0xc1009fdd4UL,0xc11d2daa3UL,0xc1264944dUL,0xc13bfb33aUL,0xc14d32ee6UL,0xc15080991UL,0xc16be477fUL,0xc17656008UL,0xc08ba7ee1UL,0xc09615996UL,0xc0ad71778UL,0xc0b0c300fUL,0xc0c60add3UL,0xc0dbb8aa4UL,0xc0e0dc44aUL,0xc0fd6e33dUL,0xc00d4fff2UL,0xc010fd885UL,0xc02b9966bUL,0xc0362b11cUL,0xc040e2cc0UL,0xc05d50bb7UL,0xc06634559UL,0xc07b8622eUL,0xdf824e527UL,0xdf9ffc250UL,0xdfa498cbeUL,0xdfb92abc9UL,0xdfcfe3615UL,0xdfd251162UL,0xdfe935f8cUL,0xdff4878fbUL,0xdf04a6434UL,0xdf1914343UL,0xdf2270dadUL,0xdf3fc2adaUL,0xdf490b706UL,0xdf54b9071UL,0xdf6fdde9fUL,0xdf726f9e8UL,0xde8f9e701UL,0xde922c076UL,0xdea948e98UL,0xdeb4fa9efUL,0xdec233433UL,0xdedf81344UL,0xdee4e5daaUL,0xdef957addUL,0xde0976612UL,0xde14c4165UL,0xde2fa0f8bUL,0xde32128fcUL,0xde44db520UL,0xde5969257UL,0xde620dcb9UL,0xde7fbfbceUL,0xdd845c61cUL,0xdd99ee16bUL,0xdda28af85UL,0xddbf388f2UL,0xddc9f152eUL,0xddd443259UL,0xddef27cb7UL,0xddf295bc0UL,0xdd02b470fUL,0xdd1f06078UL,0xdd2462e96UL,0xdd39d09e1UL,0xdd4f1943dUL,0xdd52ab34aUL,0xdd69cfda4UL,0xdd747dad3UL,0xdc898c43aUL,0xdc943e34dUL,0xdcaf5ada3UL,0xdcb2e8ad4UL,0xdcc421708UL,0xdcd99307fUL,0xdce2f7e91UL,0xdcff459e6UL,0xdc0f64529UL,0xdc12d625eUL,0xdc29b2cb0UL,0xdc3400bc7UL,0xdc42c961bUL,0xdc5f7b16cUL,0xdc641ff82UL,0xdc79ad8f5UL,0xdb8e6a351UL,0xdb93d8426UL,0xdba8bcac8UL,0xdbb50edbfUL,0xdbc3c7063UL,0xdbde75714UL,0xdbe5119faUL,0xdbf8a3e8dUL,0xdb0882242UL,0xdb1530535UL,0xdb2e54bdbUL,0xdb33e6cacUL,0xdb452f170UL,0xdb589d607UL,0xdb63f98e9UL,0xdb7e4bf9eUL,0xda83ba177UL,0xda9e08600UL,0xdaa56c8eeUL,0xdab8def99UL,0xdace17245UL,0xdad3a5532UL,0xdae8c1bdcUL,0xdaf573cabUL,0xda0552064UL,0xda18e0713UL,0xda23849fdUL,0xda3e36e8aUL,0xda48ff356UL,0xda554d421UL,0xda6e29acfUL,0xda739bdb8UL,0xd9887806aUL,0xd995ca71dUL,0xd9aeae9f3UL,0xd9b31ce84UL,0xd9c5d5358UL,0xd9d86742fUL,0xd9e303ac1UL,0xd9feb1db6UL,0xd90e90179UL,0xd9132260eUL,0xd928468e0UL,0xd935f4f97UL,0xd9433d24bUL,0xd95e8f53cUL,0xd965ebbd2UL,0xd97859ca5UL,0xd885a824cUL,0xd8981a53bUL,0xd8a37ebd5UL,0xd8beccca2UL,0xd8c80517eUL,0xd8d5b7609UL,0xd8eed38e7UL,0xd8f361f90UL,0xd8034035fUL,0xd81ef2428UL,0xd82596ac6UL,0xd83824db1UL,0xd84eed06dUL,0xd8535f71aUL,0xd8683b9f4UL,0xd87589e83UL,0xd787b4ebcUL,0xd79a069cbUL,0xd7a162725UL,0xd7bcd0052UL,0xd7ca19d8eUL,0xd7d7abaf9UL,0xd7eccf417UL,0xd7f17d360UL,0xd7015cfafUL,0xd71cee8d8UL,0xd7278a636UL,0xd73a38141UL,0xd74cf1c9dUL,0xd75143beaUL,0xd76a27504UL,0xd77795273UL,0xd68a64c9aUL,0xd697d6bedUL,0xd6acb2503UL,0xd6b100274UL,0xd6c7c9fa8UL,0xd6da7b8dfUL,0xd6e11f631UL,0xd6fcad146UL,0xd60c8cd89UL,0xd6113eafeUL,0xd62a5a410UL,0xd637e8367UL,0xd64121ebbUL,0xd65c939ccUL,0xd667f7722UL,0xd67a45055UL,0xd581a6d87UL,0xd59c14af0UL,0xd5a77041eUL,0xd5bac2369UL,0xd5cc0beb5UL,0xd5d1b99c2UL,0xd5eadd72cUL,0xd5f76f05bUL,0xd5074ec94UL,0xd51afcbe3UL,0xd5219850dUL,0xd53c2a27aUL,0xd54ae3fa6UL,0xd557518d1UL,0xd56c3563fUL,0xd57187148UL,0xd48c76fa1UL,0xd491c48d6UL,0xd4aaa0638UL,0xd4b71214fUL,0xd4c1dbc93UL,0xd4dc69be4UL,0xd4e70d50aUL,0xd4fabf27dUL,0xd40a9eeb2UL,0xd4172c9c5UL,0xd42c4872bUL,0xd431fa05cUL,0xd44733d80UL,0xd45a81af7UL,0xd461e5419UL,0xd47c5736eUL,0xd38b908caUL,0xd39622fbdUL,0xd3ad46153UL,0xd3b0f4624UL,0xd3c63dbf8UL,0xd3db8fc8fUL,0xd3e0eb261UL,0xd3fd59516UL,0xd30d789d9UL,0xd310caeaeUL,0xd32bae040UL,0xd3361c737UL,0xd340d5aebUL,0xd35d67d9cUL,0xd36603372UL,0xd37bb1405UL,0xd28640aecUL,0xd29bf2d9bUL,0xd2a096375UL,0xd2bd24402UL,0xd2cbed9deUL,0xd2d65fea9UL,0xd2ed3b047UL,0xd2f089730UL,0xd200a8bffUL,0xd21d1ac88UL,0xd2267e266UL,0xd23bcc511UL,0xd24d058cdUL,0xd250b7fbaUL,0xd26bd3154UL,0xd27661623UL,0xd18d82bf1UL,0xd19030c86UL,0xd1ab54268UL,0xd1b6e651fUL,0xd1c02f8c3UL,0xd1dd9dfb4UL,0xd1e6f915aUL,0xd1fb4b62dUL,0xd10b6aae2UL,0xd116d8d95UL,0xd12dbc37bUL,0xd1300e40cUL,0xd146c79d0UL,0xd15b75ea7UL,0xd16011049UL,0xd17da373eUL,0xd080529d7UL,0xd09de0ea0UL,0xd0a68404eUL,0xd0bb36739UL,0xd0cdffae5UL,0xd0d04dd92UL,0xd0eb2937cUL,0xd0f69b40bUL,0xd006ba8c4UL,0xd01b08fb3UL,0xd0206c15dUL,0xd03dde62aUL,0xd04b17bf6UL,0xd056a5c81UL,0xd06dc126fUL,0xd07073518UL,0xef83e3b0aUL,0xef9e51c7dUL,0xefa535293UL,0xefb8875e4UL,0xefce4e838UL,0xefd3fcf4fUL,0xefe8981a1UL,0xeff52a6d6UL,0xef050ba19UL,0xef18b9d6eUL,0xef23dd380UL,0xef3e6f4f7UL,0xef48a692bUL,0xef5514e5cUL,0xef6e700b2UL,0xef73c27c5UL,0xee8e3392cUL,0xee9381e5bUL,0xeea8e50b5UL,0xeeb5577c2UL,0xeec39ea1eUL,0xeede2cd69UL,0xeee548387UL,0xeef8fa4f0UL,0xee08db83fUL,0xee1569f48UL,0xee2e0d1a6UL,0xee33bf6d1UL,0xee4576b0dUL,0xee58c4c7aUL,0xee63a0294UL,0xee7e125e3UL,0xed85f1831UL,0xed9843f46UL,0xeda3271a8UL,0xedbe956dfUL,0xedc85cb03UL,0xedd5eec74UL,0xedee8a29aUL,0xedf3385edUL,0xed0319922UL,0xed1eabe55UL,0xed25cf0bbUL,0xed387d7ccUL,0xed4eb4a10UL,0xed5306d67UL,0xed6862389UL,0xed75d04feUL,0xec8821a17UL,0xec9593d60UL,0xecaef738eUL,0xecb3454f9UL,0xecc58c925UL,0xecd83ee52UL,0xece35a0bcUL,0xecfee87cbUL,0xec0ec9b04UL,0xec137bc73UL,0xec281f29dUL,0xec35ad5eaUL,0xec4364836UL,0xec5ed6f41UL,0xec65b21afUL,0xec78006d8UL,0xeb8fc7d7cUL,0xeb9275a0bUL,0xeba9114e5UL,0xebb4a3392UL,0xebc26ae4eUL,0xebdfd8939UL,0xebe4bc7d7UL,0xebf90e0a0UL,0xeb092fc6fUL,0xeb149db18UL,0xeb2ff95f6UL,0xeb324b281UL,0xeb4482f5dUL,0xeb593082aUL,0xeb62546c4UL,0xeb7fe61b3UL,0xea8217f5aUL,0xea9fa582dUL,0xeaa4c16c3UL,0xeab9731b4UL,0xeacfbac68UL,0xead208b1fUL,0xeae96c5f1UL,0xeaf4de286UL,0xea04ffe49UL,0xea194d93eUL,0xea22297d0UL,0xea3f9b0a7UL,0xea4952d7bUL,0xea54e0a0cUL,0xea6f844e2UL,0xea7236395UL,0xe989d5e47UL,0xe99467930UL,0xe9af037deUL,0xe9b2b10a9UL,0xe9c478d75UL,0xe9d9caa02UL,0xe9e2ae4ecUL,0xe9ff1c39bUL,0xe90f3df54UL,0xe9128f823UL,0xe929eb6cdUL,0xe934591baUL,0xe94290c66UL,0xe95f22b11UL,0xe964465ffUL,0xe979f4288UL,0xe88405c61UL,0xe899b7b16UL,0xe8a2d35f8UL,0xe8bf6128fUL,0xe8c9a8f53UL,0xe8d41a824UL,0xe8ef7e6caUL,0xe8f2cc1bdUL,0xe802edd72UL,0xe81f5fa05UL,0xe8243b4ebUL,0xe8398939cUL,0xe84f40e40UL,0xe852f2937UL,0xe869967d9UL,0xe874240aeUL,0xe78619091UL,0xe79bab7e6UL,0xe7a0cf908UL,0xe7bd7de7fUL,0xe7cbb43a3UL,0xe7d6064d4UL,0xe7ed62a3aUL,0xe7f0d0d4dUL,0xe700f1182UL,0xe71d436f5UL,0xe7262781bUL,0xe73b95f6cUL,0xe74d5c2b0UL,0xe750ee5c7UL,0xe76b8ab29UL,0xe77638c5eUL,0xe68bc92b7UL,0xe6967b5c0UL,0xe6ad1fb2eUL,0xe6b0adc59UL,0xe6c664185UL,0xe6dbd66f2UL,0xe6e0b281cUL,0xe6fd00f6bUL,0xe60d213a4UL,0xe610934d3UL,0xe62bf7a3dUL,0xe63645d4aUL,0xe6408c096UL,0xe65d3e7e1UL,0xe6665a90fUL,0xe67be8e78UL,0xe5800b3aaUL,0xe59db94ddUL,0xe5a6dda33UL,0xe5bb6fd44UL,0xe5cda6098UL,0xe5d0147efUL,0xe5eb70901UL,0xe5f6c2e76UL,0xe506e32b9UL,0xe51b515ceUL,0xe52035b20UL,0xe53d87c57UL,0xe54b4e18bUL,0xe556fc6fcUL,0xe56d98812UL,0xe5702af65UL,0xe48ddb18cUL,0xe490696fbUL,0xe4ab0d815UL,0xe4b6bff62UL,0xe4c0762beUL,0xe4ddc45c9UL,0xe4e6a0b27UL,0xe4fb12c50UL,0xe40b3309fUL,0xe416817e8UL,0xe42de5906UL,0xe43057e71UL,0xe4469e3adUL,0xe45b2c4daUL,0xe46048a34UL,0xe47dfad43UL,0xe38a3d6e7UL,0xe3978f190UL,0xe3acebf7eUL,0xe3b159809UL,0xe3c7905d5UL,0xe3da222a2UL,0xe3e146c4cUL,0xe3fcf4b3bUL,0xe30cd57f4UL,0xe31167083UL,0xe32a03e6dUL,0xe337b191aUL,0xe341784c6UL,0xe35cca3b1UL,0xe367aed5fUL,0xe37a1ca28UL,0xe287ed4c1UL,0xe29a5f3b6UL,0xe2a13bd58UL,0xe2bc89a2fUL,0xe2ca407f3UL,0xe2d7f2084UL,0xe2ec96e6aUL,0xe2f12491dUL,0xe201055d2UL,0xe21cb72a5UL,0xe227d3c4bUL,0xe23a61b3cUL,0xe24ca86e0UL,0xe2511a197UL,0xe26a7ef79UL,0xe277cc80eUL,0xe18c2f5dcUL,0xe1919d2abUL,0xe1aaf9c45UL,0xe1b74bb32UL,0xe1c1826eeUL,0xe1dc30199UL,0xe1e754f77UL,0xe1fae6800UL,0xe10ac74cfUL,0xe117753b8UL,0xe12c11d56UL,0xe131a3a21UL,0xe1476a7fdUL,0xe15ad808aUL,0xe161bce64UL,0xe17c0e913UL,0xe081ff7faUL,0xe09c4d08dUL,0xe0a729e63UL,0xe0ba9b914UL,0xe0cc524c8UL,0xe0d1e03bfUL,0xe0ea84d51UL,0xe0f736a26UL,0xe007176e9UL,0xe01aa519eUL,0xe021c1f70UL,0xe03c73807UL,0xe04aba5dbUL,0xe057082acUL,0xe06c6cc42UL,0xe071deb35UL,0xff8816c3cUL,0xff95a4b4bUL,0xffaec05a5UL,0xffb3722d2UL,0xffc5bbf0eUL,0xffd809879UL,0xffe36d697UL,0xfffedf1e0UL,0xff0efed2fUL,0xff134ca58UL,0xff28284b6UL,0xff359a3c1UL,0xff4353e1dUL,0xff5ee196aUL,0xff6585784UL,0xff78370f3UL,0xfe85c6e1aUL,0xfe987496dUL,0xfea310783UL,0xfebea20f4UL,0xfec86bd28UL,0xfed5d9a5fUL,0xfeeebd4b1UL,0xfef30f3c6UL,0xfe032ef09UL,0xfe1e9c87eUL,0xfe25f8690UL,0xfe384a1e7UL,0xfe4e83c3bUL,0xfe5331b4cUL,0xfe68555a2UL,0xfe75e72d5UL,0xfd8e04f07UL,0xfd93b6870UL,0xfda8d269eUL,0xfdb5601e9UL,0xfdc3a9c35UL,0xfdde1bb42UL,0xfde57f5acUL,0xfdf8cd2dbUL,0xfd08ece14UL,0xfd155e963UL,0xfd2e3a78dUL,0xfd33880faUL,0xfd4541d26UL,0xfd58f3a51UL,0xfd63974bfUL,0xfd7e253c8UL,0xfc83d4d21UL,0xfc9e66a56UL,0xfca5024b8UL,0xfcb8b03cfUL,0xfcce79e13UL,0xfcd3cb964UL,0xfce8af78aUL,0xfcf51d0fdUL,0xfc053cc32UL,0xfc188eb45UL,0xfc23ea5abUL,0xfc3e582dcUL,0xfc4891f00UL,0xfc5523877UL,0xfc6e47699UL,0xfc73f51eeUL,0xfb8432a4aUL,0xfb9980d3dUL,0xfba2e43d3UL,0xfbbf564a4UL,0xfbc99f978UL,0xfbd42de0fUL,0xfbef490e1UL,0xfbf2fb796UL,0xfb02dab59UL,0xfb1f68c2eUL,0xfb240c2c0UL,0xfb39be5b7UL,0xfb4f7786bUL,0xfb52c5f1cUL,0xfb69a11f2UL,0xfb7413685UL,0xfa89e286cUL,0xfa9450f1bUL,0xfaaf341f5UL,0xfab286682UL,0xfac44fb5eUL,0xfad9fdc29UL,0xfae2992c7UL,0xfaff2b5b0UL,0xfa0f0a97fUL,0xfa12b8e08UL,0xfa29dc0e6UL,0xfa346e791UL,0xfa42a7a4dUL,0xfa5f15d3aUL,0xfa64713d4UL,0xfa79c34a3UL,0xf98220971UL,0xf99f92e06UL,0xf9a4f60e8UL,0xf9b94479fUL,0xf9cf8da43UL,0xf9d23fd34UL,0xf9e95b3daUL,0xf9f4e94adUL,0xf904c8862UL,0xf9197af15UL,0xf9221e1fbUL,0xf93fac68cUL,0xf94965b50UL,0xf954d7c27UL,0xf96fb32c9UL,0xf972015beUL,0xf88ff0b57UL,0xf89242c20UL,0xf8a9262ceUL,0xf8b4945b9UL,0xf8c25d865UL,0xf8dfeff12UL,0xf8e48b1fcUL,0xf8f93968bUL,0xf80918a44UL,0xf814aad33UL,0xf82fce3ddUL,0xf8327c4aaUL,0xf844b5976UL,0xf85907e01UL,0xf862630efUL,0xf87fd1798UL,0xf78dec7a7UL,0xf7905e0d0UL,0xf7ab3ae3eUL,0xf7b688949UL,0xf7c041495UL,0xf7ddf33e2UL,0xf7e697d0cUL,0xf7fb25a7bUL,0xf70b046b4UL,0xf716b61c3UL,0xf72dd2f2dUL,0xf7306085aUL,0xf746a9586UL,0xf75b1b2f1UL,0xf7607fc1fUL,0xf77dcdb68UL,0xf6803c581UL,0xf69d8e2f6UL,0xf6a6eac18UL,0xf6bb58b6fUL,0xf6cd916b3UL,0xf6d0231c4UL,0xf6eb47f2aUL,0xf6f6f585dUL,0xf606d4492UL,0xf61b663e5UL,0xf62002d0bUL,0xf63db0a7cUL,0xf64b797a0UL,0xf656cb0d7UL,0xf66dafe39UL,0xf6701d94eUL,0xf58bfe49cUL,0xf5964c3ebUL,0xf5ad28d05UL,0xf5b09aa72UL,0xf5c6537aeUL,0xf5dbe10d9UL,0xf5e085e37UL,0xf5fd37940UL,0xf50d1658fUL,0xf510a42f8UL,0xf52bc0c16UL,0xf53672b61UL,0xf540bb6bdUL,0xf55d091caUL,0xf5666df24UL,0xf57bdf853UL,0xf4862e6baUL,0xf49b9c1cdUL,0xf4a0f8f23UL,0xf4bd4a854UL,0xf4cb83588UL,0xf4d6312ffUL,0xf4ed55c11UL,0xf4f0e7b66UL,0xf400c67a9UL,0xf41d740deUL,0xf42610e30UL,0xf43ba2947UL,0xf44d6b49bUL,0xf450d93ecUL,0xf46bbdd02UL,0xf4760fa75UL,0xf381c81d1UL,0xf39c7a6a6UL,0xf3a71e848UL,0xf3baacf3fUL,0xf3cc652e3UL,0xf3d1d7594UL,0xf3eab3b7aUL,0xf3f701c0dUL,0xf307200c2UL,0xf31a927b5UL,0xf321f695bUL,0xf33c44e2cUL,0xf34a8d3f0UL,0xf3573f487UL,0xf36c5ba69UL,0xf371e9d1eUL,0xf28c183f7UL,0xf291aa480UL,0xf2aacea6eUL,0xf2b77cd19UL,0xf2c1b50c5UL,0xf2dc077b2UL,0xf2e76395cUL,0xf2fad1e2bUL,0xf20af02e4UL,0xf21742593UL,0xf22c26b7dUL,0xf23194c0aUL,0xf2475d1d6UL,0xf25aef6a1UL,0xf2618b84fUL,0xf27c39f38UL,0xf187da2eaUL,0xf19a6859dUL,0xf1a10cb73UL,0xf1bcbec04UL,0xf1ca771d8UL,0xf1d7c56afUL,0xf1eca1841UL,0xf1f113f36UL,0xf101323f9UL,0xf11c8048eUL,0xf127e4a60UL,0xf13a56d17UL,0xf14c9f0cbUL,0xf1512d7bcUL,0xf16a49952UL,0xf177fbe25UL,0xf08a0a0ccUL,0xf097b87bbUL,0xf0acdc955UL,0xf0b16ee22UL,0xf0c7a73feUL,0xf0da15489UL,0xf0e171a67UL,0xf0fcc3d10UL,0xf00ce21dfUL,0xf011506a8UL,0xf02a34846UL,0xf03786f31UL,0xf0414f2edUL,0xf05cfd59aUL,0xf06799b74UL,0xf07a2bc03UL,0xf8f0caa5UL,0xf92bedd2UL,0xfa9da33cUL,0xfb46844bUL,0xfc2a1997UL,0xfdf13ee0UL,0xfe47700eUL,0xff9c5779UL,0xf09e4bb6UL,0xf1456cc1UL,0xf2f3222fUL,0xf3280558UL,0xf4449884UL,0xf59fbff3UL,0xf629f11dUL,0xf7f2d66aUL,0xe82dc883UL,0xe9f6eff4UL,0xea40a11aUL,0xeb9b866dUL,0xecf71bb1UL,0xed2c3cc6UL,0xee9a7228UL,0xef41555fUL,0xe0434990UL,0xe1986ee7UL,0xe22e2009UL,0xe3f5077eUL,0xe4999aa2UL,0xe542bdd5UL,0xe6f4f33bUL,0xe72fd44cUL,0xd891e99eUL,0xd94acee9UL,0xdafc8007UL,0xdb27a770UL,0xdc4b3aacUL,0xdd901ddbUL,0xde265335UL,0xdffd7442UL,0xd0ff688dUL,0xd1244ffaUL,0xd2920114UL,0xd3492663UL,0xd425bbbfUL,0xd5fe9cc8UL,0xd648d226UL,0xd793f551UL,0xc84cebb8UL,0xc997cccfUL,0xca218221UL,0xcbfaa556UL,0xcc96388aUL,0xcd4d1ffdUL,0xcefb5113UL,0xcf207664UL,0xc0226aabUL,0xc1f94ddcUL,0xc24f0332UL,0xc3942445UL,0xc4f8b999UL,0xc5239eeeUL,0xc695d000UL,0xc74ef777UL,0xb8328cd3UL,0xb9e9aba4UL,0xba5fe54aUL,0xbb84c23dUL,0xbce85fe1UL,0xbd337896UL,0xbe853678UL,0xbf5e110fUL,0xb05c0dc0UL,0xb1872ab7UL,0xb2316459UL,0xb3ea432eUL,0xb486def2UL,0xb55df985UL,0xb6ebb76bUL,0xb730901cUL,0xa8ef8ef5UL,0xa934a982UL,0xaa82e76cUL,0xab59c01bUL,0xac355dc7UL,0xadee7ab0UL,0xae58345eUL,0xaf831329UL,0xa0810fe6UL,0xa15a2891UL,0xa2ec667fUL,0xa3374108UL,0xa45bdcd4UL,0xa580fba3UL,0xa636b54dUL,0xa7ed923aUL,0x9853afe8UL,0x9988889fUL,0x9a3ec671UL,0x9be5e106UL,0x9c897cdaUL,0x9d525badUL,0x9ee41543UL,0x9f3f3234UL,0x903d2efbUL,0x91e6098cUL,0x92504762UL,0x938b6015UL,0x94e7fdc9UL,0x953cdabeUL,0x968a9450UL,0x9751b327UL,0x888eadceUL,0x89558ab9UL,0x8ae3c457UL,0x8b38e320UL,0x8c547efcUL,0x8d8f598bUL,0x8e391765UL,0x8fe23012UL,0x80e02cddUL,0x813b0baaUL,0x828d4544UL,0x83566233UL,0x843affefUL,0x85e1d898UL,0x86579676UL,0x878cb101UL,0x78af613eUL,0x79744649UL,0x7ac208a7UL,0x7b192fd0UL,0x7c75b20cUL,0x7dae957bUL,0x7e18db95UL,0x7fc3fce2UL,0x70c1e02dUL,0x711ac75aUL,0x72ac89b4UL,0x7377aec3UL,0x741b331fUL,0x75c01468UL,0x76765a86UL,0x77ad7df1UL,0x68726318UL,0x69a9446fUL,0x6a1f0a81UL,0x6bc42df6UL,0x6ca8b02aUL,0x6d73975dUL,0x6ec5d9b3UL,0x6f1efec4UL,0x601ce20bUL,0x61c7c57cUL,0x62718b92UL,0x63aaace5UL,0x64c63139UL,0x651d164eUL,0x66ab58a0UL,0x67707fd7UL,0x58ce4205UL,0x59156572UL,0x5aa32b9cUL,0x5b780cebUL,0x5c149137UL,0x5dcfb640UL,0x5e79f8aeUL,0x5fa2dfd9UL,0x50a0c316UL,0x517be461UL,0x52cdaa8fUL,0x53168df8UL,0x547a1024UL,0x55a13753UL,0x561779bdUL,0x57cc5ecaUL,0x48134023UL,0x49c86754UL,0x4a7e29baUL,0x4ba50ecdUL,0x4cc99311UL,0x4d12b466UL,0x4ea4fa88UL,0x4f7fddffUL,0x407dc130UL,0x41a6e647UL,0x4210a8a9UL,0x43cb8fdeUL,0x44a71202UL,0x457c3575UL,0x46ca7b9bUL,0x47115cecUL,0x386d2748UL,0x39b6003fUL,0x3a004ed1UL,0x3bdb69a6UL,0x3cb7f47aUL,0x3d6cd30dUL,0x3eda9de3UL,0x3f01ba94UL,0x3003a65bUL,0x31d8812cUL,0x326ecfc2UL,0x33b5e8b5UL,0x34d97569UL,0x3502521eUL,0x36b41cf0UL,0x376f3b87UL,0x28b0256eUL,0x296b0219UL,0x2add4cf7UL,0x2b066b80UL,0x2c6af65cUL,0x2db1d12bUL,0x2e079fc5UL,0x2fdcb8b2UL,0x20dea47dUL,0x2105830aUL,0x22b3cde4UL,0x2368ea93UL,0x2404774fUL,0x25df5038UL,0x26691ed6UL,0x27b239a1UL,0x180c0473UL,0x19d72304UL,0x1a616deaUL,0x1bba4a9dUL,0x1cd6d741UL,0x1d0df036UL,0x1ebbbed8UL,0x1f6099afUL,0x10628560UL,0x11b9a217UL,0x120fecf9UL,0x13d4cb8eUL,0x14b85652UL,0x15637125UL,0x16d53fcbUL,0x170e18bcUL,0x8d10655UL,0x90a2122UL,0xabc6fccUL,0xb6748bbUL,0xc0bd567UL,0xdd0f210UL,0xe66bcfeUL,0xfbd9b89UL,0xbf8746UL,0x164a031UL,0x2d2eedfUL,0x309c9a8UL,0x4655474UL,0x5be7303UL,0x6083dedUL,0x7d31a9aUL,0x1f84f9d93UL,0x1f994bae4UL,0x1fa22f40aUL,0x1fbf9d37dUL,0x1fc954ea1UL,0x1fd4e69d6UL,0x1fef82738UL,0x1ff23004fUL,0x1f0211c80UL,0x1f1fa3bf7UL,0x1f24c7519UL,0x1f397526eUL,0x1f4fbcfb2UL,0x1f520e8c5UL,0x1f696a62bUL,0x1f74d815cUL,0x1e8929fb5UL,0x1e949b8c2UL,0x1eafff62cUL,0x1eb24d15bUL,0x1ec484c87UL,0x1ed936bf0UL,0x1ee25251eUL,0x1effe0269UL,0x1e0fc1ea6UL,0x1e12739d1UL,0x1e291773fUL,0x1e34a5048UL,0x1e426cd94UL,0x1e5fdeae3UL,0x1e64ba40dUL,0x1e790837aUL,0x1d82ebea8UL,0x1d9f599dfUL,0x1da43d731UL,0x1db98f046UL,0x1dcf46d9aUL,0x1dd2f4aedUL,0x1de990403UL,0x1df422374UL,0x1d0403fbbUL,0x1d19b18ccUL,0x1d22d5622UL,0x1d3f67155UL,0x1d49aec89UL,0x1d541cbfeUL,0x1d6f78510UL,0x1d72ca267UL,0x1c8f3bc8eUL,0x1c9289bf9UL,0x1ca9ed517UL,0x1cb45f260UL,0x1cc296fbcUL,0x1cdf248cbUL,0x1ce440625UL,0x1cf9f2152UL,0x1c09d3d9dUL,0x1c1461aeaUL,0x1c2f05404UL,0x1c32b7373UL,0x1c447eeafUL,0x1c59cc9d8UL,0x1c62a8736UL,0x1c7f1a041UL,0x1b88ddbe5UL,0x1b956fc92UL,0x1bae0b27cUL,0x1bb3b950bUL,0x1bc5708d7UL,0x1bd8c2fa0UL,0x1be3a614eUL,0x1bfe14639UL,0x1b0e35af6UL,0x1b1387d81UL,0x1b28e336fUL,0x1b3551418UL,0x1b43989c4UL,0x1b5e2aeb3UL,0x1b654e05dUL,0x1b78fc72aUL,0x1a850d9c3UL,0x1a98bfeb4UL,0x1aa3db05aUL,0x1abe6972dUL,0x1ac8a0af1UL,0x1ad512d86UL,0x1aee76368UL,0x1af3c441fUL,0x1a03e58d0UL,0x1a1e57fa7UL,0x1a2533149UL,0x1a388163eUL,0x1a4e48be2UL,0x1a53fac95UL,0x1a689e27bUL,0x1a752c50cUL,0x198ecf8deUL,0x19937dfa9UL,0x19a819147UL,0x19b5ab630UL,0x19c362becUL,0x19ded0c9bUL,0x19e5b4275UL,0x19f806502UL,0x1908279cdUL,0x191595ebaUL,0x192ef1054UL,0x193343723UL,0x19458aaffUL,0x195838d88UL,0x19635c366UL,0x197eee411UL,0x18831faf8UL,0x189eadd8fUL,0x18a5c9361UL,0x18b87b416UL,0x18ceb29caUL,0x18d300ebdUL,0x18e864053UL,0x18f5d6724UL,0x1805f7bebUL,0x181845c9cUL,0x182321272UL,0x183e93505UL,0x18485a8d9UL,0x1855e8faeUL,0x186e8c140UL,0x18733e637UL,0x178103608UL,0x179cb117fUL,0x17a7d5f91UL,0x17ba678e6UL,0x17ccae53aUL,0x17d11c24dUL,0x17ea78ca3UL,0x17f7cabd4UL,0x1707eb71bUL,0x171a5906cUL,0x17213de82UL,0x173c8f9f5UL,0x174a46429UL,0x1757f435eUL,0x176c90db0UL,0x177122ac7UL,0x168cd342eUL,0x169161359UL,0x16aa05db7UL,0x16b7b7ac0UL,0x16c17e71cUL,0x16dccc06bUL,0x16e7a8e85UL,0x16fa1a9f2UL,0x160a3b53dUL,0x16178924aUL,0x162cedca4UL,0x16315fbd3UL,0x16479660fUL,0x165a24178UL,0x166140f96UL,0x167cf28e1UL,0x158711533UL,0x159aa3244UL,0x15a1c7caaUL,0x15bc75bddUL,0x15cabc601UL,0x15d70e176UL,0x15ec6af98UL,0x15f1d88efUL,0x1501f9420UL,0x151c4b357UL,0x15272fdb9UL,0x153a9daceUL,0x154c54712UL,0x1551e6065UL,0x156a82e8bUL,0x1577309fcUL,0x148ac1715UL,0x149773062UL,0x14ac17e8cUL,0x14b1a59fbUL,0x14c76c427UL,0x14dade350UL,0x14e1badbeUL,0x14fc08ac9UL,0x140c29606UL,0x14119b171UL,0x142afff9fUL,0x14374d8e8UL,0x144184534UL,0x145c36243UL,0x146752cadUL,0x147ae0bdaUL,0x138d2707eUL,0x139095709UL,0x13abf19e7UL,0x13b643e90UL,0x13c08a34cUL,0x13dd3843bUL,0x13e65cad5UL,0x13fbeeda2UL,0x130bcf16dUL,0x13167d61aUL,0x132d198f4UL,0x1330abf83UL,0x13466225fUL,0x135bd0528UL,0x1360b4bc6UL,0x137d06cb1UL,0x1280f7258UL,0x129d4552fUL,0x12a621bc1UL,0x12bb93cb6UL,0x12cd5a16aUL,0x12d0e861dUL,0x12eb8c8f3UL,0x12f63ef84UL,0x12061f34bUL,0x121bad43cUL,0x1220c9ad2UL,0x123d7bda5UL,0x124bb2079UL,0x12560070eUL,0x126d649e0UL,0x1270d6e97UL,0x118b35345UL,0x119687432UL,0x11ade3adcUL,0x11b051dabUL,0x11c698077UL,0x11db2a700UL,0x11e04e9eeUL,0x11fdfce99UL,0x110ddd256UL,0x11106f521UL,0x112b0bbcfUL,0x1136b9cb8UL,0x114070164UL,0x115dc2613UL,0x1166a68fdUL,0x117b14f8aUL,0x1086e5163UL,0x109b57614UL,0x10a0338faUL,0x10bd81f8dUL,0x10cb48251UL,0x10d6fa526UL,0x10ed9ebc8UL,0x10f02ccbfUL,0x10000d070UL,0x101dbf707UL,0x1026db9e9UL,0x103b69e9eUL,0x104da0342UL,0x105012435UL,0x106b76adbUL,0x1076c4dacUL,0x2f85543beUL,0x2f98e64c9UL,0x2fa382a27UL,0x2fbe30d50UL,0x2fc8f908cUL,0x2fd54b7fbUL,0x2fee2f915UL,0x2ff39de62UL,0x2f03bc2adUL,0x2f1e0e5daUL,0x2f256ab34UL,0x2f38d8c43UL,0x2f4e1119fUL,0x2f53a36e8UL,0x2f68c7806UL,0x2f7575f71UL,0x2e8884198UL,0x2e95366efUL,0x2eae52801UL,0x2eb3e0f76UL,0x2ec5292aaUL,0x2ed89b5ddUL,0x2ee3ffb33UL,0x2efe4dc44UL,0x2e0e6c08bUL,0x2e13de7fcUL,0x2e28ba912UL,0x2e3508e65UL,0x2e43c13b9UL,0x2e5e734ceUL,0x2e6517a20UL,0x2e78a5d57UL,0x2d8346085UL,0x2d9ef47f2UL,0x2da59091cUL,0x2db822e6bUL,0x2dceeb3b7UL,0x2dd3594c0UL,0x2de83da2eUL,0x2df58fd59UL,0x2d05ae196UL,0x2d181c6e1UL,0x2d237880fUL,0x2d3ecaf78UL,0x2d48032a4UL,0x2d55b15d3UL,0x2d6ed5b3dUL,0x2d7367c4aUL,0x2c8e962a3UL,0x2c93245d4UL,0x2ca840b3aUL,0x2cb5f2c4dUL,0x2cc33b191UL,0x2cde896e6UL,0x2ce5ed808UL,0x2cf85ff7fUL,0x2c087e3b0UL,0x2c15cc4c7UL,0x2c2ea8a29UL,0x2c331ad5eUL,0x2c45d3082UL,0x2c58617f5UL,0x2c630591bUL,0x2c7eb7e6cUL,0x2b89705c8UL,0x2b94c22bfUL,0x2bafa6c51UL,0x2bb214b26UL,0x2bc4dd6faUL,0x2bd96f18dUL,0x2be20bf63UL,0x2bffb9814UL,0x2b0f984dbUL,0x2b122a3acUL,0x2b294ed42UL,0x2b34fca35UL,0x2b42357e9UL,0x2b5f8709eUL,0x2b64e3e70UL,0x2b7951907UL,0x2a84a07eeUL,0x2a9912099UL,0x2aa276e77UL,0x2abfc4900UL,0x2ac90d4dcUL,0x2ad4bf3abUL,0x2aefdbd45UL,0x2af269a32UL,0x2a02486fdUL,0x2a1ffa18aUL,0x2a249ef64UL,0x2a392c813UL,0x2a4fe55cfUL,0x2a52572b8UL,0x2a6933c56UL,0x2a7481b21UL,0x298f626f3UL,0x2992d0184UL,0x29a9b4f6aUL,0x29b40681dUL,0x29c2cf5c1UL,0x29df7d2b6UL,0x29e419c58UL,0x29f9abb2fUL,0x29098a7e0UL,0x291438097UL,0x292f5ce79UL,0x2932ee90eUL,0x2944274d2UL,0x2959953a5UL,0x2962f1d4bUL,0x297f43a3cUL,0x2882b24d5UL,0x289f003a2UL,0x28a464d4cUL,0x28b9d6a3bUL,0x28cf1f7e7UL,0x28d2ad090UL,0x28e9c9e7eUL,0x28f47b909UL,0x28045a5c6UL,0x2819e82b1UL,0x28228cc5fUL,0x283f3eb28UL,0x2849f76f4UL,0x285445183UL,0x286f21f6dUL,0x28729381aUL,0x2780ae825UL,0x279d1cf52UL,0x27a6781bcUL,0x27bbca6cbUL,0x27cd03b17UL,0x27d0b1c60UL,0x27ebd528eUL,0x27f6675f9UL,0x270646936UL,0x271bf4e41UL,0x2720900afUL,0x273d227d8UL,0x274beba04UL,0x275659d73UL,0x276d3d39dUL,0x27708f4eaUL,0x268d7ea03UL,0x2690ccd74UL,0x26aba839aUL,0x26b61a4edUL,0x26c0d3931UL,0x26dd61e46UL,0x26e6050a8UL,0x26fbb77dfUL,0x260b96b10UL,0x261624c67UL,0x262d40289UL,0x2630f25feUL,0x26463b822UL,0x265b89f55UL,0x2660ed1bbUL,0x267d5f6ccUL,0x2586bcb1eUL,0x259b0ec69UL,0x25a06a287UL,0x25bdd85f0UL,0x25cb1182cUL,0x25d6a3f5bUL,0x25edc71b5UL,0x25f0756c2UL,0x250054a0dUL,0x251de6d7aUL,0x252682394UL,0x253b304e3UL,0x254df993fUL,0x25504be48UL,0x256b2f0a6UL,0x25769d7d1UL,0x248b6c938UL,0x2496dee4fUL,0x24adba0a1UL,0x24b0087d6UL,0x24c6c1a0aUL,0x24db73d7dUL,0x24e017393UL,0x24fda54e4UL,0x240d8482bUL,0x241036f5cUL,0x242b521b2UL,0x2436e06c5UL,0x244029b19UL,0x245d9bc6eUL,0x2466ff280UL,0x247b4d5f7UL,0x238c8ae53UL,0x239138924UL,0x23aa5c7caUL,0x23b7ee0bdUL,0x23c127d61UL,0x23dc95a16UL,0x23e7f14f8UL,0x23fa4338fUL,0x230a62f40UL,0x2317d0837UL,0x232cb46d9UL,0x2331061aeUL,0x2347cfc72UL,0x235a7db05UL,0x2361195ebUL,0x237cab29cUL,0x22815ac75UL,0x229ce8b02UL,0x22a78c5ecUL,0x22ba3e29bUL,0x22ccf7f47UL,0x22d145830UL,0x22ea216deUL,0x22f7931a9UL,0x2207b2d66UL,0x221a00a11UL,0x2221644ffUL,0x223cd6388UL,0x224a1fe54UL,0x2257ad923UL,0x226cc97cdUL,0x22717b0baUL,0x218a98d68UL,0x21972aa1fUL,0x21ac4e4f1UL,0x21b1fc386UL,0x21c735e5aUL,0x21da8792dUL,0x21e1e37c3UL,0x21fc510b4UL,0x210c70c7bUL,0x2111c2b0cUL,0x212aa65e2UL,0x213714295UL,0x2141ddf49UL,0x215c6f83eUL,0x21670b6d0UL,0x217ab91a7UL,0x208748f4eUL,0x209afa839UL,0x20a19e6d7UL,0x20bc2c1a0UL,0x20cae5c7cUL,0x20d757b0bUL,0x20ec335e5UL,0x20f181292UL,0x2001a0e5dUL,0x201c1292aUL,0x2027767c4UL,0x203ac40b3UL,0x204c0dd6fUL,0x2051bfa18UL,0x206adb4f6UL,0x207769381UL,0x3f8ea1488UL,0x3f93133ffUL,0x3fa877d11UL,0x3fb5c5a66UL,0x3fc30c7baUL,0x3fdebe0cdUL,0x3fe5dae23UL,0x3ff868954UL,0x3f084959bUL,0x3f15fb2ecUL,0x3f2e9fc02UL,0x3f332db75UL,0x3f45e46a9UL,0x3f58561deUL,0x3f6332f30UL,0x3f7e80847UL,0x3e83716aeUL,0x3e9ec31d9UL,0x3ea5a7f37UL,0x3eb815840UL,0x3ecedc59cUL,0x3ed36e2ebUL,0x3ee80ac05UL,0x3ef5b8b72UL,0x3e05997bdUL,0x3e182b0caUL,0x3e234fe24UL,0x3e3efd953UL,0x3e483448fUL,0x3e55863f8UL,0x3e6ee2d16UL,0x3e7350a61UL,0x3d88b37b3UL,0x3d95010c4UL,0x3dae65e2aUL,0x3db3d795dUL,0x3dc51e481UL,0x3dd8ac3f6UL,0x3de3c8d18UL,0x3dfe7aa6fUL,0x3d0e5b6a0UL,0x3d13e91d7UL,0x3d288df39UL,0x3d353f84eUL,0x3d43f6592UL,0x3d5e442e5UL,0x3d6520c0bUL,0x3d7892b7cUL,0x3c8563595UL,0x3c98d12e2UL,0x3ca3b5c0cUL,0x3cbe07b7bUL,0x3cc8ce6a7UL,0x3cd57c1d0UL,0x3cee18f3eUL,0x3cf3aa849UL,0x3c038b486UL,0x3c1e393f1UL,0x3c255dd1fUL,0x3c38efa68UL,0x3c4e267b4UL,0x3c53940c3UL,0x3c68f0e2dUL,0x3c754295aUL,0x3b82852feUL,0x3b9f37589UL,0x3ba453b67UL,0x3bb9e1c10UL,0x3bcf281ccUL,0x3bd29a6bbUL,0x3be9fe855UL,0x3bf44cf22UL,0x3b046d3edUL,0x3b19df49aUL,0x3b22bba74UL,0x3b3f09d03UL,0x3b49c00dfUL,0x3b54727a8UL,0x3b6f16946UL,0x3b72a4e31UL,0x3a8f550d8UL,0x3a92e77afUL,0x3aa983941UL,0x3ab431e36UL,0x3ac2f83eaUL,0x3adf4a49dUL,0x3ae42ea73UL,0x3af99cd04UL,0x3a09bd1cbUL,0x3a140f6bcUL,0x3a2f6b852UL,0x3a32d9f25UL,0x3a44102f9UL,0x3a59a258eUL,0x3a62c6b60UL,0x3a7f74c17UL,0x3984971c5UL,0x3999256b2UL,0x39a24185cUL,0x39bff3f2bUL,0x39c93a2f7UL,0x39d488580UL,0x39efecb6eUL,0x39f25ec19UL,0x39027f0d6UL,0x391fcd7a1UL,0x3924a994fUL,0x39391be38UL,0x394fd23e4UL,0x395260493UL,0x396904a7dUL,0x3974b6d0aUL,0x3889473e3UL,0x3894f5494UL,0x38af91a7aUL,0x38b223d0dUL,0x38c4ea0d1UL,0x38d9587a6UL,0x38e23c948UL,0x38ff8ee3fUL,0x380faf2f0UL,0x38121d587UL,0x382979b69UL,0x3834cbc1eUL,0x3842021c2UL,0x385fb06b5UL,0x3864d485bUL,0x387966f2cUL,0x378b5bf13UL,0x3796e9864UL,0x37ad8d68aUL,0x37b03f1fdUL,0x37c6f6c21UL,0x37db44b56UL,0x37e0205b8UL,0x37fd922cfUL,0x370db3e00UL,0x371001977UL,0x372b65799UL,0x3736d70eeUL,0x37401ed32UL,0x375daca45UL,0x3766c84abUL,0x377b7a3dcUL,0x36868bd35UL,0x369b39a42UL,0x36a05d4acUL,0x36bdef3dbUL,0x36cb26e07UL,0x36d694970UL,0x36edf079eUL,0x36f0420e9UL,0x360063c26UL,0x361dd1b51UL,0x3626b55bfUL,0x363b072c8UL,0x364dcef14UL,0x36507c863UL,0x366b1868dUL,0x3676aa1faUL,0x358d49c28UL,0x3590fbb5fUL,0x35ab9f5b1UL,0x35b62d2c6UL,0x35c0e4f1aUL,0x35dd5686dUL,0x35e632683UL,0x35fb801f4UL,0x350ba1d3bUL,0x351613a4cUL,0x352d774a2UL,0x3530c53d5UL,0x35460ce09UL,0x355bbe97eUL,0x3560da790UL,0x357d680e7UL,0x348099e0eUL,0x349d2b979UL,0x34a64f797UL,0x34bbfd0e0UL,0x34cd34d3cUL,0x34d086a4bUL,0x34ebe24a5UL,0x34f6503d2UL,0x340671f1dUL,0x341bc386aUL,0x3420a7684UL,0x343d151f3UL,0x344bdcc2fUL,0x34566eb58UL,0x346d0a5b6UL,0x3470b82c1UL,0x33877f965UL,0x339acde12UL,0x33a1a90fcUL,0x33bc1b78bUL,0x33cad2a57UL,0x33d760d20UL,0x33ec043ceUL,0x33f1b64b9UL,0x330197876UL,0x331c25f01UL,0x3327411efUL,0x333af3698UL,0x334c3ab44UL,0x335188c33UL,0x336aec2ddUL,0x33775e5aaUL,0x328aafb43UL,0x32971dc34UL,0x32ac792daUL,0x32b1cb5adUL,0x32c702871UL,0x32dab0f06UL,0x32e1d41e8UL,0x32fc6669fUL,0x320c47a50UL,0x3211f5d27UL,0x322a913c9UL,0x3237234beUL,0x3241ea962UL,0x325c58e15UL,0x32673c0fbUL,0x327a8e78cUL,0x31816da5eUL,0x319cdfd29UL,0x31a7bb3c7UL,0x31ba094b0UL,0x31ccc096cUL,0x31d172e1bUL,0x31ea160f5UL,0x31f7a4782UL,0x310785b4dUL,0x311a37c3aUL,0x3121532d4UL,0x313ce15a3UL,0x314a2887fUL,0x31579af08UL,0x316cfe1e6UL,0x31714c691UL,0x308cbd878UL,0x30910ff0fUL,0x30aa6b1e1UL,0x30b7d9696UL,0x30c110b4aUL,0x30dca2c3dUL,0x30e7c62d3UL,0x30fa745a4UL,0x300a5596bUL,0x3017e7e1cUL,0x302c830f2UL,0x303131785UL,0x3047f8a59UL,0x305a4ad2eUL,0x30612e3c0UL,0x307c9c4b7UL,0x4f860ffe4UL,0x4f9bbd893UL,0x4fa0d967dUL,0x4fbd6b10aUL,0x4fcba2cd6UL,0x4fd610ba1UL,0x4fed7454fUL,0x4ff0c6238UL,0x4f00e7ef7UL,0x4f1d55980UL,0x4f263176eUL,0x4f3b83019UL,0x4f4d4adc5UL,0x4f50f8ab2UL,0x4f6b9c45cUL,0x4f762e32bUL,0x4e8bdfdc2UL,0x4e966dab5UL,0x4ead0945bUL,0x4eb0bb32cUL,0x4ec672ef0UL,0x4edbc0987UL,0x4ee0a4769UL,0x4efd1601eUL,0x4e0d37cd1UL,0x4e1085ba6UL,0x4e2be1548UL,0x4e365323fUL,0x4e409afe3UL,0x4e5d28894UL,0x4e664c67aUL,0x4e7bfe10dUL,0x4d801dcdfUL,0x4d9dafba8UL,0x4da6cb546UL,0x4dbb79231UL,0x4dcdb0fedUL,0x4dd00289aUL,0x4deb66674UL,0x4df6d4103UL,0x4d06f5dccUL,0x4d1b47abbUL,0x4d2023455UL,0x4d3d91322UL,0x4d4b58efeUL,0x4d56ea989UL,0x4d6d8e767UL,0x4d703c010UL,0x4c8dcdef9UL,0x4c907f98eUL,0x4cab1b760UL,0x4cb6a9017UL,0x4cc060dcbUL,0x4cddd2abcUL,0x4ce6b6452UL,0x4cfb04325UL,0x4c0b25feaUL,0x4c169789dUL,0x4c2df3673UL,0x4c3041104UL,0x4c4688cd8UL,0x4c5b3abafUL,0x4c605e541UL,0x4c7dec236UL,0x4b8a2b992UL,0x4b9799ee5UL,0x4bacfd00bUL,0x4bb14f77cUL,0x4bc786aa0UL,0x4bda34dd7UL,0x4be150339UL,0x4bfce244eUL,0x4b0cc3881UL,0x4b1171ff6UL,0x4b2a15118UL,0x4b37a766fUL,0x4b416ebb3UL,0x4b5cdccc4UL,0x4b67b822aUL,0x4b7a0a55dUL,0x4a87fbbb4UL,0x4a9a49cc3UL,0x4aa12d22dUL,0x4abc9f55aUL,0x4aca56886UL,0x4ad7e4ff1UL,0x4aec8011fUL,0x4af132668UL,0x4a0113aa7UL,0x4a1ca1dd0UL,0x4a27c533eUL,0x4a3a77449UL,0x4a4cbe995UL,0x4a510cee2UL,0x4a6a6800cUL,0x4a77da77bUL,0x498c39aa9UL,0x49918bddeUL,0x49aaef330UL,0x49b75d447UL,0x49c19499bUL,0x49dc26eecUL,0x49e742002UL,0x49faf0775UL,0x490ad1bbaUL,0x491763ccdUL,0x492c07223UL,0x4931b5554UL,0x49477c888UL,0x495acefffUL,0x4961aa111UL,0x497c18666UL,0x4881e988fUL,0x489c5bff8UL,0x48a73f116UL,0x48ba8d661UL,0x48cc44bbdUL,0x48d1f6ccaUL,0x48ea92224UL,0x48f720553UL,0x48070199cUL,0x481ab3eebUL,0x4821d7005UL,0x483c65772UL,0x484aacaaeUL,0x48571edd9UL,0x486c7a337UL,0x4871c8440UL,0x4783f547fUL,0x479e47308UL,0x47a523de6UL,0x47b891a91UL,0x47ce5874dUL,0x47d3ea03aUL,0x47e88eed4UL,0x47f53c9a3UL,0x47051d56cUL,0x4718af21bUL,0x4723cbcf5UL,0x473e79b82UL,0x4748b065eUL,0x475502129UL,0x476e66fc7UL,0x4773d48b0UL,0x468e25659UL,0x46939712eUL,0x46a8f3fc0UL,0x46b5418b7UL,0x46c38856bUL,0x46de3a21cUL,0x46e55ecf2UL,0x46f8ecb85UL,0x4608cd74aUL,0x46157f03dUL,0x462e1bed3UL,0x4633a99a4UL,0x464560478UL,0x4658d230fUL,0x4663b6de1UL,0x467e04a96UL,0x4585e7744UL,0x459855033UL,0x45a331eddUL,0x45be839aaUL,0x45c84a476UL,0x45d5f8301UL,0x45ee9cdefUL,0x45f32ea98UL,0x45030f657UL,0x451ebd120UL,0x4525d9fceUL,0x45386b8b9UL,0x454ea2565UL,0x455310212UL,0x456874cfcUL,0x4575c6b8bUL,0x448837562UL,0x449585215UL,0x44aee1cfbUL,0x44b353b8cUL,0x44c59a650UL,0x44d828127UL,0x44e34cfc9UL,0x44fefe8beUL,0x440edf471UL,0x44136d306UL,0x442809de8UL,0x4435bba9fUL,0x444372743UL,0x445ec0034UL,0x4465a4edaUL,0x4478169adUL,0x438fd1209UL,0x43926357eUL,0x43a907b90UL,0x43b4b5ce7UL,0x43c27c13bUL,0x43dfce64cUL,0x43e4aa8a2UL,0x43f918fd5UL,0x43093931aUL,0x43148b46dUL,0x432fefa83UL,0x43325ddf4UL,0x434494028UL,0x43592675fUL,0x4362429b1UL,0x437ff0ec6UL,0x42820102fUL,0x429fb3758UL,0x42a4d79b6UL,0x42b965ec1UL,0x42cfac31dUL,0x42d21e46aUL,0x42e97aa84UL,0x42f4c8df3UL,0x4204e913cUL,0x42195b64bUL,0x42223f8a5UL,0x423f8dfd2UL,0x42494420eUL,0x4254f6579UL,0x426f92b97UL,0x427220ce0UL,0x4189c3132UL,0x419471645UL,0x41af158abUL,0x41b2a7fdcUL,0x41c46e200UL,0x41d9dc577UL,0x41e2b8b99UL,0x41ff0aceeUL,0x410f2b021UL,0x411299756UL,0x4129fd9b8UL,0x41344fecfUL,0x414286313UL,0x415f34464UL,0x416450a8aUL,0x4179e2dfdUL,0x408413314UL,0x4099a1463UL,0x40a2c5a8dUL,0x40bf77dfaUL,0x40c9be026UL,0x40d40c751UL,0x40ef689bfUL,0x40f2daec8UL,0x4002fb207UL,0x401f49570UL,0x40242db9eUL,0x40399fce9UL,0x404f56135UL,0x4052e4642UL,0x4069808acUL,0x407432fdbUL,0x5f8dfa8d2UL,0x5f9048fa5UL,0x5fab2c14bUL,0x5fb69e63cUL,0x5fc057be0UL,0x5fdde5c97UL,0x5fe681279UL,0x5ffb3350eUL,0x5f0b129c1UL,0x5f16a0eb6UL,0x5f2dc4058UL,0x5f307672fUL,0x5f46bfaf3UL,0x5f5b0dd84UL,0x5f606936aUL,0x5f7ddb41dUL,0x5e802aaf4UL,0x5e9d98d83UL,0x5ea6fc36dUL,0x5ebb4e41aUL,0x5ecd879c6UL,0x5ed035eb1UL,0x5eeb5105fUL,0x5ef6e3728UL,0x5e06c2be7UL,0x5e1b70c90UL,0x5e201427eUL,0x5e3da6509UL,0x5e4b6f8d5UL,0x5e56ddfa2UL,0x5e6db914cUL,0x5e700b63bUL,0x5d8be8be9UL,0x5d965ac9eUL,0x5dad3e270UL,0x5db08c507UL,0x5dc6458dbUL,0x5ddbf7facUL,0x5de093142UL,0x5dfd21635UL,0x5d0d00afaUL,0x5d10b2d8dUL,0x5d2bd6363UL,0x5d3664414UL,0x5d40ad9c8UL,0x5d5d1febfUL,0x5d667b051UL,0x5d7bc9726UL,0x5c86389cfUL,0x5c9b8aeb8UL,0x5ca0ee056UL,0x5cbd5c721UL,0x5ccb95afdUL,0x5cd627d8aUL,0x5ced43364UL,0x5cf0f1413UL,0x5c00d08dcUL,0x5c1d62fabUL,0x5c2606145UL,0x5c3bb4632UL,0x5c4d7dbeeUL,0x5c50cfc99UL,0x5c6bab277UL,0x5c7619500UL,0x5b81deea4UL,0x5b9c6c9d3UL,0x5ba70873dUL,0x5bbaba04aUL,0x5bcc73d96UL,0x5bd1c1ae1UL,0x5beaa540fUL,0x5bf717378UL,0x5b0736fb7UL,0x5b1a848c0UL,0x5b21e062eUL,0x5b3c52159UL,0x5b4a9bc85UL,0x5b5729bf2UL,0x5b6c4d51cUL,0x5b71ff26bUL,0x5a8c0ec82UL,0x5a91bcbf5UL,0x5aaad851bUL,0x5ab76a26cUL,0x5ac1a3fb0UL,0x5adc118c7UL,0x5ae775629UL,0x5afac715eUL,0x5a0ae6d91UL,0x5a1754ae6UL,0x5a2c30408UL,0x5a318237fUL,0x5a474bea3UL,0x5a5af99d4UL,0x5a619d73aUL,0x5a7c2f04dUL,0x5987ccd9fUL,0x599a7eae8UL,0x59a11a406UL,0x59bca8371UL,0x59ca61eadUL,0x59d7d39daUL,0x59ecb7734UL,0x59f105043UL,0x590124c8cUL,0x591c96bfbUL,0x5927f2515UL,0x593a40262UL,0x594c89fbeUL,0x59513b8c9UL,0x596a5f627UL,0x5977ed150UL,0x588a1cfb9UL,0x5897ae8ceUL,0x58acca620UL,0x58b178157UL,0x58c7b1c8bUL,0x58da03bfcUL,0x58e167512UL,0x58fcd5265UL,0x580cf4eaaUL,0x5811469ddUL,0x582a22733UL,0x583790044UL,0x584159d98UL,0x585cebaefUL,0x58678f401UL,0x587a3d376UL,0x578800349UL,0x5795b243eUL,0x57aed6ad0UL,0x57b364da7UL,0x57c5ad07bUL,0x57d81f70cUL,0x57e37b9e2UL,0x57fec9e95UL,0x570ee825aUL,0x57135a52dUL,0x57283ebc3UL,0x57358ccb4UL,0x574345168UL,0x575ef761fUL,0x5765938f1UL,0x577821f86UL,0x5685d016fUL,0x569862618UL,0x56a3068f6UL,0x56beb4f81UL,0x56c87d25dUL,0x56d5cf52aUL,0x56eeabbc4UL,0x56f319cb3UL,0x56033807cUL,0x561e8a70bUL,0x5625ee9e5UL,0x56385ce92UL,0x564e9534eUL,0x565327439UL,0x566843ad7UL,0x5675f1da0UL,0x558e12072UL,0x5593a0705UL,0x55a8c49ebUL,0x55b576e9cUL,0x55c3bf340UL,0x55de0d437UL,0x55e569ad9UL,0x55f8dbdaeUL,0x5508fa161UL,0x551548616UL,0x552e2c8f8UL,0x55339ef8fUL,0x554557253UL,0x5558e5524UL,0x556381bcaUL,0x557e33cbdUL,0x5483c2254UL,0x549e70523UL,0x54a514bcdUL,0x54b8a6cbaUL,0x54ce6f166UL,0x54d3dd611UL,0x54e8b98ffUL,0x54f50bf88UL,0x54052a347UL,0x541898430UL,0x5423fcadeUL,0x543e4eda9UL,0x544887075UL,0x545535702UL,0x546e519ecUL,0x5473e3e9bUL,0x53842453fUL,0x539996248UL,0x53a2f2ca6UL,0x53bf40bd1UL,0x53c98960dUL,0x53d43b17aUL,0x53ef5ff94UL,0x53f2ed8e3UL,0x5302cc42cUL,0x531f7e35bUL,0x53241adb5UL,0x5339a8ac2UL,0x534f6171eUL,0x5352d3069UL,0x5369b7e87UL,0x5374059f0UL,0x5289f4719UL,0x52944606eUL,0x52af22e80UL,0x52b2909f7UL,0x52c45942bUL,0x52d9eb35cUL,0x52e28fdb2UL,0x52ff3dac5UL,0x520f1c60aUL,0x5212ae17dUL,0x5229caf93UL,0x5234788e4UL,0x5242b1538UL,0x525f0324fUL,0x526467ca1UL,0x5279d5bd6UL,0x518236604UL,0x519f84173UL,0x51a4e0f9dUL,0x51b9528eaUL,0x51cf9b536UL,0x51d229241UL,0x51e94dcafUL,0x51f4ffbd8UL,0x5104de717UL,0x51196c060UL,0x512208e8eUL,0x513fba9f9UL,0x514973425UL,0x5154c1352UL,0x516fa5dbcUL,0x517217acbUL,0x508fe6422UL,0x509254355UL,0x50a930dbbUL,0x50b482accUL,0x50c24b710UL,0x50dff9067UL,0x50e49de89UL,0x50f92f9feUL,0x50090e531UL,0x5014bc246UL,0x502fd8ca8UL,0x50326abdfUL,0x5044a3603UL,0x505911174UL,0x506275f9aUL,0x507fc78edUL,0x6f8c576ffUL,0x6f91e5188UL,0x6faa81f66UL,0x6fb733811UL,0x6fc1fa5cdUL,0x6fdc482baUL,0x6fe72cc54UL,0x6ffa9eb23UL,0x6f0abf7ecUL,0x6f170d09bUL,0x6f2c69e75UL,0x6f31db902UL,0x6f47124deUL,0x6f5aa03a9UL,0x6f61c4d47UL,0x6f7c76a30UL,0x6e81874d9UL,0x6e9c353aeUL,0x6ea751d40UL,0x6ebae3a37UL,0x6ecc2a7ebUL,0x6ed19809cUL,0x6eeafce72UL,0x6ef74e905UL,0x6e076f5caUL,0x6e1add2bdUL,0x6e21b9c53UL,0x6e3c0bb24UL,0x6e4ac26f8UL,0x6e577018fUL,0x6e6c14f61UL,0x6e71a6816UL,0x6d8a455c4UL,0x6d97f72b3UL,0x6dac93c5dUL,0x6db121b2aUL,0x6dc7e86f6UL,0x6dda5a181UL,0x6de13ef6fUL,0x6dfc8c818UL,0x6d0cad4d7UL,0x6d111f3a0UL,0x6d2a7bd4eUL,0x6d37c9a39UL,0x6d41007e5UL,0x6d5cb2092UL,0x6d67d6e7cUL,0x6d7a6490bUL,0x6c87957e2UL,0x6c9a27095UL,0x6ca143e7bUL,0x6cbcf190cUL,0x6cca384d0UL,0x6cd78a3a7UL,0x6ceceed49UL,0x6cf15ca3eUL,0x6c017d6f1UL,0x6c1ccf186UL,0x6c27abf68UL,0x6c3a1981fUL,0x6c4cd05c3UL,0x6c51622b4UL,0x6c6a06c5aUL,0x6c77b4b2dUL,0x6b8073089UL,0x6b9dc17feUL,0x6ba6a5910UL,0x6bbb17e67UL,0x6bcdde3bbUL,0x6bd06c4ccUL,0x6beb08a22UL,0x6bf6bad55UL,0x6b069b19aUL,0x6b1b296edUL,0x6b204d803UL,0x6b3dfff74UL,0x6b4b362a8UL,0x6b56845dfUL,0x6b6de0b31UL,0x6b7052c46UL,0x6a8da32afUL,0x6a90115d8UL,0x6aab75b36UL,0x6ab6c7c41UL,0x6ac00e19dUL,0x6addbc6eaUL,0x6ae6d8804UL,0x6afb6af73UL,0x6a0b4b3bcUL,0x6a16f94cbUL,0x6a2d9da25UL,0x6a302fd52UL,0x6a46e608eUL,0x6a5b547f9UL,0x6a6030917UL,0x6a7d82e60UL,0x6986613b2UL,0x699bd34c5UL,0x69a0b7a2bUL,0x69bd05d5cUL,0x69cbcc080UL,0x69d67e7f7UL,0x69ed1a919UL,0x69f0a8e6eUL,0x6900892a1UL,0x691d3b5d6UL,0x69265fb38UL,0x693bedc4fUL,0x694d24193UL,0x6950966e4UL,0x696bf280aUL,0x697640f7dUL,0x688bb1194UL,0x6896036e3UL,0x68ad6780dUL,0x68b0d5f7aUL,0x68c61c2a6UL,0x68dbae5d1UL,0x68e0cab3fUL,0x68fd78c48UL,0x680d59087UL,0x6810eb7f0UL,0x682b8f91eUL,0x68363de69UL,0x6840f43b5UL,0x685d464c2UL,0x686622a2cUL,0x687b90d5bUL,0x6789add64UL,0x67941fa13UL,0x67af7b4fdUL,0x67b2c938aUL,0x67c400e56UL,0x67d9b2921UL,0x67e2d67cfUL,0x67ff640b8UL,0x670f45c77UL,0x6712f7b00UL,0x6729935eeUL,0x673421299UL,0x6742e8f45UL,0x675f5a832UL,0x67643e6dcUL,0x67798c1abUL,0x66847df42UL,0x6699cf835UL,0x66a2ab6dbUL,0x66bf191acUL,0x66c9d0c70UL,0x66d462b07UL,0x66ef065e9UL,0x66f2b429eUL,0x660295e51UL,0x661f27926UL,0x6624437c8UL,0x6639f10bfUL,0x664f38d63UL,0x66528aa14UL,0x6669ee4faUL,0x66745c38dUL,0x658fbfe5fUL,0x65920d928UL,0x65a9697c6UL,0x65b4db0b1UL,0x65c212d6dUL,0x65dfa0a1aUL,0x65e4c44f4UL,0x65f976383UL,0x650957f4cUL,0x6514e583bUL,0x652f816d5UL,0x6532331a2UL,0x6544fac7eUL,0x655948b09UL,0x65622c5e7UL,0x657f9e290UL,0x64826fc79UL,0x649fddb0eUL,0x64a4b95e0UL,0x64b90b297UL,0x64cfc2f4bUL,0x64d27083cUL,0x64e9146d2UL,0x64f4a61a5UL,0x640487d6aUL,0x641935a1dUL,0x6422514f3UL,0x643fe3384UL,0x64492ae58UL,0x64549892fUL,0x646ffc7c1UL,0x64724e0b6UL,0x638589b12UL,0x63983bc65UL,0x63a35f28bUL,0x63beed5fcUL,0x63c824820UL,0x63d596f57UL,0x63eef21b9UL,0x63f3406ceUL,0x630361a01UL,0x631ed3d76UL,0x6325b7398UL,0x6338054efUL,0x634ecc933UL,0x63537ee44UL,0x63681a0aaUL,0x6375a87ddUL,0x628859934UL,0x6295ebe43UL,0x62ae8f0adUL,0x62b33d7daUL,0x62c5f4a06UL,0x62d846d71UL,0x62e32239fUL,0x62fe904e8UL,0x620eb1827UL,0x621303f50UL,0x6228671beUL,0x6235d56c9UL,0x62431cb15UL,0x625eaec62UL,0x6265ca28cUL,0x6278785fbUL,0x61839b829UL,0x619e29f5eUL,0x61a54d1b0UL,0x61b8ff6c7UL,0x61ce36b1bUL,0x61d384c6cUL,0x61e8e0282UL,0x61f5525f5UL,0x61057393aUL,0x6118c1e4dUL,0x6123a50a3UL,0x613e177d4UL,0x6148dea08UL,0x61556cd7fUL,0x616e08391UL,0x6173ba4e6UL,0x608e4ba0fUL,0x6093f9d78UL,0x60a89d396UL,0x60b52f4e1UL,0x60c3e693dUL,0x60de54e4aUL,0x60e5300a4UL,0x60f8827d3UL,0x6008a3b1cUL,0x601511c6bUL,0x602e75285UL,0x6033c75f2UL,0x60450e82eUL,0x6058bcf59UL,0x6063d81b7UL,0x607e6a6c0UL,0x7f87a21c9UL,0x7f9a106beUL,0x7fa174850UL,0x7fbcc6f27UL,0x7fca0f2fbUL,0x7fd7bd58cUL,0x7fecd9b62UL,0x7ff16bc15UL,0x7f014a0daUL,0x7f1cf87adUL,0x7f279c943UL,0x7f3a2ee34UL,0x7f4ce73e8UL,0x7f515549fUL,0x7f6a31a71UL,0x7f7783d06UL,0x7e8a723efUL,0x7e97c0498UL,0x7eaca4a76UL,0x7eb116d01UL,0x7ec7df0ddUL,0x7eda6d7aaUL,0x7ee109944UL,0x7efcbbe33UL,0x7e0c9a2fcUL,0x7e112858bUL,0x7e2a4cb65UL,0x7e37fec12UL,0x7e41371ceUL,0x7e5c856b9UL,0x7e67e1857UL,0x7e7a53f20UL,0x7d81b02f2UL,0x7d9c02585UL,0x7da766b6bUL,0x7dbad4c1cUL,0x7dcc1d1c0UL,0x7dd1af6b7UL,0x7deacb859UL,0x7df779f2eUL,0x7d07583e1UL,0x7d1aea496UL,0x7d218ea78UL,0x7d3c3cd0fUL,0x7d4af50d3UL,0x7d57477a4UL,0x7d6c2394aUL,0x7d7191e3dUL,0x7c8c600d4UL,0x7c91d27a3UL,0x7caab694dUL,0x7cb704e3aUL,0x7cc1cd3e6UL,0x7cdc7f491UL,0x7ce71ba7fUL,0x7cfaa9d08UL,0x7c0a881c7UL,0x7c173a6b0UL,0x7c2c5e85eUL,0x7c31ecf29UL,0x7c47252f5UL,0x7c5a97582UL,0x7c61f3b6cUL,0x7c7c41c1bUL,0x7b8b867bfUL,0x7b96340c8UL,0x7bad50e26UL,0x7bb0e2951UL,0x7bc62b48dUL,0x7bdb993faUL,0x7be0fdd14UL,0x7bfd4fa63UL,0x7b0d6e6acUL,0x7b10dc1dbUL,0x7b2bb8f35UL,0x7b360a842UL,0x7b40c359eUL,0x7b5d712e9UL,0x7b6615c07UL,0x7b7ba7b70UL,0x7a8656599UL,0x7a9be42eeUL,0x7aa080c00UL,0x7abd32b77UL,0x7acbfb6abUL,0x7ad6491dcUL,0x7aed2df32UL,0x7af09f845UL,0x7a00be48aUL,0x7a1d0c3fdUL,0x7a2668d13UL,0x7a3bdaa64UL,0x7a4d137b8UL,0x7a50a10cfUL,0x7a6bc5e21UL,0x7a7677956UL,0x798d94484UL,0x7990263f3UL,0x79ab42d1dUL,0x79b6f0a6aUL,0x79c0397b6UL,0x79dd8b0c1UL,0x79e6efe2fUL,0x79fb5d958UL,0x790b7c597UL,0x7916ce2e0UL,0x792daac0eUL,0x793018b79UL,0x7946d16a5UL,0x795b631d2UL,0x796007f3cUL,0x797db584bUL,0x7880446a2UL,0x789df61d5UL,0x78a692f3bUL,0x78bb2084cUL,0x78cde9590UL,0x78d05b2e7UL,0x78eb3fc09UL,0x78f68db7eUL,0x7806ac7b1UL,0x781b1e0c6UL,0x78207ae28UL,0x783dc895fUL,0x784b01483UL,0x7856b33f4UL,0x786dd7d1aUL,0x787065a6dUL,0x778258a52UL,0x779fead25UL,0x77a48e3cbUL,0x77b93c4bcUL,0x77cff5960UL,0x77d247e17UL,0x77e9230f9UL,0x77f49178eUL,0x7704b0b41UL,0x771902c36UL,0x7722662d8UL,0x773fd45afUL,0x77491d873UL,0x7754aff04UL,0x776fcb1eaUL,0x77727969dUL,0x768f88874UL,0x76923af03UL,0x76a95e1edUL,0x76b4ec69aUL,0x76c225b46UL,0x76df97c31UL,0x76e4f32dfUL,0x76f9415a8UL,0x760960967UL,0x7614d2e10UL,0x762fb60feUL,0x763204789UL,0x7644cda55UL,0x76597fd22UL,0x76621b3ccUL,0x767fa94bbUL,0x75844a969UL,0x7599f8e1eUL,0x75a29c0f0UL,0x75bf2e787UL,0x75c9e7a5bUL,0x75d455d2cUL,0x75ef313c2UL,0x75f2834b5UL,0x7502a287aUL,0x751f10f0dUL,0x7524741e3UL,0x7539c6694UL,0x754f0fb48UL,0x7552bdc3fUL,0x7569d92d1UL,0x75746b5a6UL,0x74899ab4fUL,0x749428c38UL,0x74af4c2d6UL,0x74b2fe5a1UL,0x74c43787dUL,0x74d985f0aUL,0x74e2e11e4UL,0x74ff53693UL,0x740f72a5cUL,0x7412c0d2bUL,0x7429a43c5UL,0x7434164b2UL,0x7442df96eUL,0x745f6de19UL,0x7464090f7UL,0x7479bb780UL,0x738e7cc24UL,0x7393ceb53UL,0x73a8aa5bdUL,0x73b5182caUL,0x73c3d1f16UL,0x73de63861UL,0x73e50768fUL,0x73f8b51f8UL,0x730894d37UL,0x731526a40UL,0x732e424aeUL,0x7333f03d9UL,0x734539e05UL,0x73588b972UL,0x7363ef79cUL,0x737e5d0ebUL,0x7283ace02UL,0x729e1e975UL,0x72a57a79bUL,0x72b8c80ecUL,0x72ce01d30UL,0x72d3b3a47UL,0x72e8d74a9UL,0x72f5653deUL,0x720544f11UL,0x7218f6866UL,0x722392688UL,0x723e201ffUL,0x7248e9c23UL,0x72555bb54UL,0x726e3f5baUL,0x72738d2cdUL,0x71886ef1fUL,0x7195dc868UL,0x71aeb8686UL,0x71b30a1f1UL,0x71c5c3c2dUL,0x71d871b5aUL,0x71e3155b4UL,0x71fea72c3UL,0x710e86e0cUL,0x71133497bUL,0x712850795UL,0x7135e20e2UL,0x71432bd3eUL,0x715e99a49UL,0x7165fd4a7UL,0x71784f3d0UL,0x7085bed39UL,0x70980ca4eUL,0x70a3684a0UL,0x70beda3d7UL,0x70c813e0bUL,0x70d5a197cUL,0x70eec5792UL,0x70f3770e5UL,0x700356c2aUL,0x701ee4b5dUL,0x7025805b3UL,0x7038322c4UL,0x704efbf18UL,0x70534986fUL,0x70682d681UL,0x70759f1f6UL}; + fromVector(codes,d._code_id); + d._nbits=36; + d._tau=2;// + d._type=ARTOOLKITPLUSBCH; + d._name="ARTOOLKITPLUSBCH"; + + }break; + case TAG36h11:{ +vector codes={0xd5d628584UL,0xd97f18b49UL,0xdd280910eUL,0xe479e9c98UL,0xebcbca822UL,0xf31dab3acUL,0x56a5d085UL,0x10652e1d4UL,0x22b1dfeadUL,0x265ad0472UL,0x34fe91b86UL,0x3ff962cd5UL,0x43a25329aUL,0x474b4385fUL,0x4e9d243e9UL,0x5246149aeUL,0x5997f5538UL,0x683bb6c4cUL,0x6be4a7211UL,0x7e3158eeaUL,0x81da494afUL,0x858339a74UL,0x8cd51a5feUL,0x9f21cc2d7UL,0xa2cabc89cUL,0xadc58d9ebUL,0xb16e7dfb0UL,0xb8c05eb3aUL,0xd25ef139dUL,0xd607e1962UL,0xe4aba3076UL,0x2dde6a3daUL,0x43d40c678UL,0x5620be351UL,0x64c47fa65UL,0x686d7002aUL,0x6c16605efUL,0x6fbf50bb4UL,0x8d06d39dcUL,0x9f53856b5UL,0xadf746dc9UL,0xbc9b084ddUL,0xd290aa77bUL,0xd9e28b305UL,0xe4dd5c454UL,0xfad2fe6f2UL,0x181a8151aUL,0x26be42c2eUL,0x2e10237b8UL,0x405cd5491UL,0x7742eab1cUL,0x85e6ac230UL,0x8d388cdbaUL,0x9f853ea93UL,0xc41ea2445UL,0xcf1973594UL,0x14a34a333UL,0x31eacd15bUL,0x6c79d2dabUL,0x73cbb3935UL,0x89c155bd3UL,0x8d6a46198UL,0x91133675dUL,0xa708d89fbUL,0xae5ab9585UL,0xb9558a6d4UL,0xb98743ab2UL,0xd6cec68daUL,0x1506bcaefUL,0x4becd217aUL,0x4f95c273fUL,0x658b649ddUL,0xa76c4b1b7UL,0xecf621f56UL,0x1c8a56a57UL,0x3628e92baUL,0x53706c0e2UL,0x5e6b3d231UL,0x7809cfa94UL,0xe97eead6fUL,0x5af40604aUL,0x7492988adUL,0xed5994712UL,0x5eceaf9edUL,0x7c1632815UL,0xc1a0095b4UL,0xe9e25d52bUL,0x3a6705419UL,0xa8333012fUL,0x4ce5704d0UL,0x508e60a95UL,0x877476120UL,0xa864e950dUL,0xea45cfce7UL,0x19da047e8UL,0x24d4d5937UL,0x6e079cc9bUL,0x99f2e11d7UL,0x33aa50429UL,0x499ff26c7UL,0x50f1d3251UL,0x66e7754efUL,0x96ad633ceUL,0x9a5653993UL,0xaca30566cUL,0xc298a790aUL,0x8be44b65dUL,0xdc68f354bUL,0x16f7f919bUL,0x4dde0e826UL,0xd548cbd9fUL,0xe0439ceeeUL,0xfd8b1fd16UL,0x76521bb7bUL,0xd92375742UL,0xcab16d40cUL,0x730c9dd72UL,0xad9ba39c2UL,0xb14493f87UL,0x52b15651fUL,0x185409cadUL,0x77ae2c68dUL,0x94f5af4b5UL,0xa13bad55UL,0x61ea437cdUL,0xa022399e2UL,0x203b163d1UL,0x7bba8f40eUL,0x95bc9442dUL,0x41c0b5358UL,0x8e9c6cc81UL,0xeb549670UL,0x9da3a0b51UL,0xd832a67a1UL,0xdcd4350bcUL,0x4aa05fdd2UL,0x60c7bb44eUL,0x4b358b96cUL,0x67299b45UL,0xb9c89b5faUL,0x6975acaeaUL,0x62b8f7afaUL,0x33567c3d7UL,0xbac139950UL,0xa5927c62aUL,0x5c916e6a4UL,0x260ecb7d5UL,0x29b7bbd9aUL,0x903205f26UL,0xae72270a4UL,0x3d2ec51a7UL,0x82ea55324UL,0x11a6f3427UL,0x1ca1c4576UL,0xa40c81aefUL,0xbddccd730UL,0xe617561eUL,0x969317b0fUL,0x67f781364UL,0x610912f96UL,0xb2549fdfcUL,0x6e5aaa6bUL,0xb6c475339UL,0xc56836a4dUL,0x844e351ebUL,0x4647f83b4UL,0x908a04f5UL,0x7f51034c9UL,0xaee537fcaUL,0x5e92494baUL,0xd445808f4UL,0x28d68b563UL,0x4d25374bUL,0x2bc065f65UL,0x96dc3ea0cUL,0x4b2ade817UL,0x7c3fd502UL,0xe768b5cafUL,0x17605cf6cUL,0x182741ee4UL,0x62846097cUL,0x72b5ebf80UL,0x263da6e13UL,0xfa841bcb5UL,0x7e45e8c69UL,0x653c81fa0UL,0x7443b5e70UL,0xa5234afdUL,0x74756f24eUL,0x157ebf02aUL,0x82ef46939UL,0x80d420264UL,0x2aeed3e98UL,0xb0a1dd4f8UL,0xb5436be13UL,0x7b7b4b13bUL,0x1ce80d6d3UL,0x16c08427dUL,0xee54462ddUL,0x1f7644cceUL,0x9c7b5cc92UL,0xe369138f8UL,0x5d5a66e91UL,0x485d62f49UL,0xe6e819e94UL,0xb1f340eb5UL,0x9d198ce2UL,0xd60717437UL,0x196b856cUL,0xf0a6173a5UL,0x12c0e1ec6UL,0x62b82d5cfUL,0xad154c067UL,0xce3778832UL,0x6b0a7b864UL,0x4c7686694UL,0x5058ff3ecUL,0xd5e21ea23UL,0x9ff4a76eeUL,0x9dd981019UL,0x1bad4d30aUL,0xc601896d1UL,0x973439b48UL,0x1ce7431a8UL,0x57a8021d6UL,0xf9dba96e6UL,0x83a2e4e7cUL,0x8ea585380UL,0xaf6c0e744UL,0x875b73babUL,0xda34ca901UL,0x2ab9727efUL,0xd39f21b9aUL,0x8a10b742fUL,0x5f8952dbaUL,0xf8da71ab0UL,0xc25f9df96UL,0x6f8a5d94UL,0xe42e63e1aUL,0xb78409d1bUL,0x792229addUL,0x5acf8c455UL,0x2fc29a9b0UL,0xea486237bUL,0xb0c9685a0UL,0x1ad748a47UL,0x3b4712d5UL,0xf29216d30UL,0x8dad65e49UL,0xa2cf09ddUL,0xb5f174c6UL,0xe54f57743UL,0xb9cf54d78UL,0x4a312a88aUL,0x27babc962UL,0xb86897111UL,0xf2ff6c116UL,0x82274bd8aUL,0x97023505eUL,0x52d46edd1UL,0x585c1f538UL,0xbddd00e43UL,0x5590b74dfUL,0x729404a1fUL,0x65320855eUL,0xd3d4b6956UL,0x7ae374f14UL,0x2d7a60e06UL,0x315cd9b5eUL,0xfd36b4eacUL,0xf1df7642bUL,0x55db27726UL,0x8f15ebc19UL,0x992f8c531UL,0x62dea2a40UL,0x928275cabUL,0x69c263cb9UL,0xa774cca9eUL,0x266b2110eUL,0x1b14acbb8UL,0x624b8a71bUL,0x1c539406bUL,0x3086d529bUL,0x111dd66eUL,0x98cd630bfUL,0x8b9d1ffdcUL,0x72b2f61e7UL,0x9ed9d672bUL,0x96cdd15f3UL,0x6366c2504UL,0x6ca9df73aUL,0xa066d60f0UL,0xe7a4b8addUL,0x8264647efUL,0xaa195bf81UL,0x9a3db8244UL,0x14d2df6aUL,0xb63265b7UL,0x2f010de73UL,0x97e774986UL,0x248affc29UL,0xfb57dcd11UL,0xb1a7e4d9UL,0x4bfa2d07dUL,0x54e5cdf96UL,0x4c15c1c86UL,0xcd9c61166UL,0x499380b2aUL,0x540308d09UL,0x8b63fe66fUL,0xc81aeb35eUL,0x86fe0bd5cUL,0xce2480c2aUL,0x1ab29ee60UL,0x8048daa15UL,0xdbfeb2d39UL,0x567c9858cUL,0x2b6edc5bcUL,0x2078fca82UL,0xadacc22aaUL,0xb92486f49UL,0x51fac5964UL,0x691ee6420UL,0xf63b3e129UL,0x39be7e572UL,0xda2ce6c74UL,0x20cf17a5cUL,0xee55f9b6eUL,0xfb8572726UL,0xb2c2de548UL,0xcaa9bce92UL,0xae9182db3UL,0x74b6e5bd1UL,0x137b252afUL,0x51f686881UL,0xd672f6c02UL,0x654146ce4UL,0xf944bc825UL,0xe8327f809UL,0x76a73fd59UL,0xf79da4cb4UL,0x956f8099bUL,0x7b5f2655cUL,0xd06b114a6UL,0xd0697ca50UL,0x27c390797UL,0xbc61ed9b2UL,0xcc12dd19bUL,0xeb7818d2cUL,0x92fcecdaUL,0x89ded4ea1UL,0x256a0ba34UL,0xb6948e627UL,0x1ef6b1054UL,0x8639294a2UL,0xeda3780a4UL,0x39ee2af1dUL,0xcd257edc5UL,0x2d9d6bc22UL,0x121d3b47dUL,0x37e23f8adUL,0x119f31cf6UL,0x2c97f4f09UL,0xd502abfe0UL,0x10bc3ca77UL,0x53d7190efUL,0x90c3e62a6UL,0x7e9ebf675UL,0x979ce23d1UL,0x27f0c98e9UL,0xeafb4ae59UL,0x7ca7fe2bdUL,0x1490ca8f6UL,0x9123387baUL,0xb3bc73888UL,0x3ea87e325UL,0x4888964aaUL,0xa0188a6b9UL,0xcd383c666UL,0x40029a3fdUL,0xe1c00ac5cUL,0x39e6f2b6eUL,0xde664f622UL,0xe979a75e8UL,0x7c6b4c86cUL,0xfd492e071UL,0x8fbb35118UL,0x40b4a09b7UL,0xaf80bd6daUL,0x70e0b2521UL,0x2f5c54d93UL,0x3f4a118d5UL,0x9c1897b9UL,0x79776eacUL,0x84b00b17UL,0x3a95ad90eUL,0x28c544095UL,0x39d457c05UL,0x7a3791a78UL,0xbb770e22eUL,0x9a822bd6cUL,0x68a4b1fedUL,0xa5fd27b3bUL,0xc3995b79UL,0xd1519dff1UL,0x8e7eee359UL,0xcd3ca50b1UL,0xb73b8b793UL,0x57aca1c43UL,0xec2655277UL,0x785a2c1b3UL,0x75a07985aUL,0xa4b01eb69UL,0xa18a11347UL,0xdb1f28ca3UL,0x877ec3e25UL,0x31f6341b8UL,0x1363a3a4cUL,0x75d8b9baUL,0x7ae0792a9UL,0xa83a21651UL,0x7f08f9fb5UL,0xd0cf73a9UL,0xb04dcc98eUL,0xf65c7b0f8UL,0x65ddaf69aUL,0x2cf9b86b3UL,0x14cb51e25UL,0xf48027b5bUL,0xec26ea8bUL,0x44bafd45cUL,0xb12c7c0c4UL,0x959fd9d82UL,0xc77c9725aUL,0x48a22d462UL,0x8398e8072UL,0xec89b05ceUL,0xbb682d4c9UL,0xe5a86d2ffUL,0x358f01134UL,0x8556ddcf6UL,0x67584b6e2UL,0x11609439fUL,0x8488816eUL,0xaaf1a2c46UL,0xf879898cfUL,0x8bbe5e2f7UL,0x101eee363UL,0x690f69377UL,0xf5bd93cd9UL,0xcea4c2bf6UL,0x9550be706UL,0x2c5b38a60UL,0xe72033547UL,0x4458b0629UL,0xee8d9ed41UL,0xd2f918d72UL,0x78dc39fd3UL,0x8212636f6UL,0x7450a72a7UL,0xc4f0cf4c6UL,0x367bcddcdUL,0xc1caf8cc6UL,0xa7f5b853dUL,0x9d536818bUL,0x535e021b0UL,0xa7eb8729eUL,0x422a67b49UL,0x929e928a6UL,0x48e8aefccUL,0xa9897393cUL,0x5eb81d37eUL,0x1e80287b7UL,0x34770d903UL,0x2eef86728UL,0x59266ccb6UL,0x110bba61UL,0x1dfd284efUL,0x447439d1bUL,0xfece0e599UL,0x9309f3703UL,0x80764d1ddUL,0x353f1e6a0UL,0x2c1c12dccUL,0xc1d21b9d7UL,0x457ee453eUL,0xd66faf540UL,0x44831e652UL,0xcfd49a848UL,0x9312d4133UL,0x3f097d3eeUL,0x8c9ebef7aUL,0xa99e29e88UL,0xe9fab22cUL,0x4e748f4fbUL,0xecdee4288UL,0xabce5f1d0UL,0xc42f6876cUL,0x7ed402ea0UL,0xe5c4242c3UL,0xd5b2c31aeUL,0x286863be6UL,0x160444d94UL,0x5f0f5808eUL,0xae3d44b2aUL,0x9f5c5d109UL,0x8ad9316d7UL,0x3422ba064UL,0x2fed11d56UL,0xbea6e3e04UL,0x4b029eecUL,0x6deed7435UL,0x3718ce17cUL,0x55857f5e2UL,0x2edac7b62UL,0x85d6c512UL,0xd6ca88e0fUL,0x2b7e1fc69UL,0xa699d5c1bUL,0xf05ad74deUL,0x4cf5fb56dUL,0x5725e07e1UL,0x72f18a2deUL,0x1cec52609UL,0x48534243cUL,0x2523a4d69UL,0x35c1b80d1UL,0xa4d7338a7UL,0xdb1af012UL,0xe61a9475dUL,0x5df03f91UL,0x97ae260bbUL,0x32d627fefUL,0xb640f73c2UL,0x45a1ac9c6UL,0x6a2202de1UL,0x57d3e25f2UL,0x5aa9f986eUL,0xcc859d8aUL,0xe3ec6cca8UL,0x54e95e1aeUL,0x446887b06UL,0x7516732beUL,0x3817ac8f5UL,0x3e26d938cUL,0xaa81bc235UL,0xdf387ca1bUL,0xf3a3b3f2UL,0xb4bf69677UL,0xae21868edUL,0x81e1d2d9dUL,0xa0a9ea14cUL,0x8eee297a9UL,0x4740c0559UL,0xe8b141837UL,0xac69e0a3dUL,0x9ed83a1e1UL,0x5edb55ecbUL,0x7340fe81UL,0x50dfbc6bfUL,0x4f583508aUL,0xcb1fb78bcUL,0x4025ced2fUL,0x39791ebecUL,0x53ee388f1UL,0x7d6c0bd23UL,0x93a995fbeUL,0x8a41728deUL,0x2fe70e053UL,0xab3db443aUL,0x1364edb05UL,0x47b6eeed6UL,0x12e71af01UL,0x52ff83587UL,0x3a1575dd8UL,0x3feaa3564UL,0xeacf78ba7UL,0x872b94f8UL,0xda8ddf9a2UL,0x9aa920d2bUL,0x1f350ed36UL,0x18a5e861fUL,0x2c35b89c3UL,0x3347ac48aUL,0x7f23e022eUL,0x2459068fbUL,0xe83be4b73UL}; +fromVector(codes,d._code_id); + d._nbits=36; + d._tau=11; + d._type=TAG36h11; + d._name="TAG36h11"; + + }break; + case TAG36h10:{ + vector codes={0x1ca92a687UL,0x20521ac4cUL,0x27a3fb7d6UL,0x2b4cebd9bUL,0x3647bceeaUL,0x39f0ad4afUL,0x3d999da74UL,0x44eb7e5feUL,0x538f3fd12UL,0x5738302d7UL,0x65dbf19ebUL,0x70d6c2b3aUL,0x7f7a8424eUL,0x832374813UL,0x86cc64dd8UL,0x8a755539dUL,0x9570264ecUL,0x991916ab1UL,0xa06af763bUL,0xab65c878aUL,0xb2b7a9314UL,0xb660998d9UL,0xbdb27a463UL,0xcc563bb77UL,0xe24bdde15UL,0xed46aef64UL,0xf4988faeeUL,0x6e5417c7UL,0x158902edbUL,0x1cdae3a65UL,0x242cc45efUL,0x27d5b4bb4UL,0x2b7ea5179UL,0x32d085d03UL,0x3679762c8UL,0x3a226688dUL,0x3dcb56e52UL,0x48c627fa1UL,0x5769e96b5UL,0x6264ba804UL,0x660daadc9UL,0x6d5f8b953UL,0x74b16c4ddUL,0x7fac3d62cUL,0x91f8ef305UL,0x95a1df8caUL,0x994acfe8fUL,0xa09cb0a19UL,0xa445a0fdeUL,0xa7ee915a3UL,0xab9781b68UL,0xaf407212dUL,0xb69252cb7UL,0xc8df04990UL,0xd3d9d5adfUL,0xd782c60a4UL,0xf12158907UL,0x1d0c9ce43UL,0x20b58d408UL,0x2f594eb1cUL,0x3a541fc6bUL,0x454ef0dbaUL,0x53f2b24ceUL,0x629673be2UL,0x74e3258bbUL,0x8ad8c7b59UL,0x9d2579832UL,0xa8204a981UL,0xaf722b50bUL,0xb6c40c095UL,0xba6cfc65aUL,0xf15311ce5UL,0x748b3f83UL,0xaf1a4548UL,0xe9a94b0dUL,0x2be217935UL,0x3e2ec960eUL,0x4cd28ad22UL,0x507b7b2e7UL,0x54246b8acUL,0x57cd5be71UL,0x6a1a0db4aUL,0x6dc2fe10fUL,0x876190972UL,0x99ae4264bUL,0xabfaf4324UL,0xc9427714cUL,0xd09457cd6UL,0xd43d4829bUL,0xea32ea539UL,0xf52dbb688UL,0x161e2ea75UL,0x286ae074eUL,0x66a2d6963UL,0x8b3c3a315UL,0x8ee52a8daUL,0xa131dc5b3UL,0xe6bbb3352UL,0xf55f74a66UL,0x5a45bb5UL,0x7ac2673fUL,0x1da1c89ddUL,0x289c99b2cUL,0x3ae94b805UL,0x50deedaa3UL,0x5830ce62dUL,0x5bd9bebf2UL,0x632b9f77cUL,0x6e26708cbUL,0x841c12b69UL,0x92bfd427dUL,0x9668c4842UL,0x9dbaa53ccUL,0xb007570a5UL,0xb3b04766aUL,0xc25408d7eUL,0xea965ccf5UL,0xf93a1e409UL,0x434ef558UL,0x1681a1231UL,0x1dd381dbbUL,0x302033a94UL,0x75aa0a833UL,0x92f18d65bUL,0x9a436e1e5UL,0xa1954ed6fUL,0xb78af100dUL,0xbb33e15d2UL,0xc62eb2721UL,0x466a8936UL,0xf6179a85UL,0x16b35a60fUL,0x589440de9UL,0x6738024fdUL,0x847f85325UL,0x9e1e17b88UL,0xacc1d929cUL,0xb06ac9861UL,0xd5042d213UL,0xfd468118aUL,0xf9332e63UL,0x342c96815UL,0x37d586ddaUL,0x551d09c02UL,0x5c6eea78cUL,0x6017dad51UL,0x9354ffe17UL,0x9aa6e09a1UL,0xa94aa20b5UL,0xacf39267aUL,0xbb9753d8eUL,0xbf4044353UL,0x8730b6b7UL,0x1716ccdcbUL,0x22119df1aUL,0x3f5920d42UL,0x58f7b35a5UL,0x6b446527eUL,0x972fa97baUL,0x9e818a344UL,0xa5d36aeceUL,0xd1beaf40aUL,0xdcb980559UL,0xf65812dbcUL,0x139f95be4UL,0x6b761e65cUL,0x6f1f0ec21UL,0xa605242acUL,0xe43d1a4c1UL,0x29c6f1260UL,0x386ab2974UL,0x4e6054c12UL,0x8c984ae27UL,0x97931bf76UL,0x9ee4fcb00UL,0xd22221bc6UL,0xe46ed389fUL,0xebc0b4429UL,0x6f82813ddUL,0x732b719a2UL,0x9072f47caUL,0x941be4d8fUL,0x97c4d5354UL,0x9f16b5edeUL,0xb8b548741UL,0xd253dafa4UL,0xd5fccb569UL,0xd9a5bbb2eUL,0xe4a08cc7dUL,0x3c77156f5UL,0x7aaf0b90aUL,0xb53e1155aUL,0xb8e701b1fUL,0x5c2b9448UL,0x14667ab5cUL,0x47a39fc22UL,0x4ef5807acUL,0x64eb22a4aUL,0x982847b10UL,0xaa74f97e9UL,0xae1de9daeUL,0xb56fca938UL,0xf750b1112UL,0x1bea14ac4UL,0x1f9305089UL,0x233bf564eUL,0x31dfb6d62UL,0x3931978ecUL,0x52d02a14fUL,0x5a220acd9UL,0xb1f893751UL,0xfb2b5aab5UL,0x40b531854UL,0x5a53c40b7UL,0x8d90e917dUL,0x9139d9742UL,0x94e2c9d07UL,0xd6c3b04e1UL,0xe910621baUL,0xf40b33309UL,0x1152b6131UL,0x32432951eUL,0x3d3dfa66dUL,0x65804e5e4UL,0xab0a25383UL,0xb604f64d2UL,0xde474a449UL,0x11846f50fUL,0x6d03e854cUL,0x7455c90d6UL,0xab3bde761UL,0xdad013262UL,0xe973d4976UL,0x2b54bb150UL,0x9577f58a1UL,0x9920e5e66UL,0xb66868c8eUL,0xf4a05eea3UL,0x3dd326207UL,0x5b1aa902fUL,0x99529f244UL,0xb2f131aa7UL,0xd038b48cfUL,0xd3e1a4e94UL,0x24664cd82UL,0x36b2fea5bUL,0x95db6805dUL,0xa0d6391acUL,0xabd10a2fbUL,0x15f444a4cUL,0x2be9e6ceaUL,0x57d52b226UL,0x5f270bdb0UL,0xb6fd94828UL,0x879b19105UL,0xd476d0a2eUL,0xe6c382707UL,0xdbfa6a996UL,0x1689705e6UL,0x3b22d3f98UL,0x636527f0fUL,0x7d03ba772UL,0xee78d5a4dUL,0xbf165a32aUL,0xc2bf4a8efUL,0x517be89f2UL,0x67718ac90UL,0x6b1a7b255UL,0x726c5bddfUL,0xbb9f23143UL,0x1375abbbbUL,0x296b4de59UL,0x8893b745bUL,0xa9842a848UL,0xb827ebf5cUL,0x3840c894bUL,0x6b7deda11UL,0xbc02958ffUL,0x55ba04b51UL,0x76aa77f3eUL,0x9b43db8f0UL,0x9eeccbeb5UL,0xa295bc47aUL,0xb4e26e153UL,0xe476a2c54UL,0x6be1601cdUL,0x6f8a50792UL,0x97cca4709UL,0xbc66080bbUL,0x1093a056eUL,0x6fbc09b70UL,0xb8eed0ed4UL,0xcee473172UL,0x23120b625UL,0x5da111275UL,0xcf162c550UL,0xec8f68756UL,0xb5db0c4a9UL,0x2b2ad1127UL,0x536d2509eUL,0x9c9fec402UL,0xc1394fdb4UL,0x6c326b53UL,0x5e99af5cbUL,0xaf1e574b9UL,0xe6046cb44UL,0x661d49533UL,0x8e5f9d4aaUL,0xdb3b54dd3UL,0xe63625f22UL,0xe9df164e7UL,0x455e8f524UL,0x5b54317c2UL,0xbe258b389UL,0x54340a016UL,0x5b85eaba0UL,0x1284dcc1aUL,0x24d18e8f3UL,0x4d13e286aUL,0x8b4bd8a7fUL,0x215a5770cUL,0x46572d87aUL,0xc2c719ca4UL,0x4ddac77e2UL,0xd19c94796UL,0x2d1c0d7d3UL,0x9ae8384e9UL,0x9e9128aaeUL,0xca7c6cfeaUL,0x16282675UL,0xad985c97eUL,0x4af8bc195UL,0x9f580da26UL,0xa6a9ee5b0UL,0xbc9f9084eUL,0xd63e230b1UL,0xc4232a7b6UL,0xd66fdc48fUL,0xec657e72dUL,0xa364707a7UL,0xf79208c5aUL,0xde88a1f91UL,0x574f9ddf6UL,0x65f35f50aUL,0x69ce08eadUL,0x490f4ee9eUL,0xc9282b88dUL,0x752c4c7b8UL,0xb364429cdUL,0x8b53a7e34UL,0xbe90ccefaUL,0xb0507dfa2UL,0xd525e90UL,0x5c549eecdUL,0xe3bf5c446UL,0x936c6d936UL,0x9747172d9UL,0xca843c39fUL,0xd57f0d4eeUL,0x2d5595f66UL,0xbfbb2462eUL,0x266727b98UL,0x7ac679429UL,0x26fc53732UL,0x656602d25UL,0x2eb1a6a78UL,0x4850392dbUL,0xe5b098af2UL,0xab534c280UL,0x9ce143f4aUL,0xf4b7cc9c2UL,0x35b8e0d6UL,0x871d5b08aUL,0x5b958930aUL,0xb429a7faUL,0x54d8d431aUL,0x7d1b28291UL,0xa1e645021UL,0xb80da069dUL,0xeef3b5d28UL,0x263d3db6fUL,0x9592d503UL,0x4b9d86499UL,0x6c8df9886UL,0xa3740ef11UL,0xc4963b6dcUL,0x6da94672UL,0x53b64bf9bUL,0xb2deb559dUL,0xf116ab7b2UL,0x8ace1aa04UL,0x8ea8c43a7UL,0x6a4119dd3UL,0x99d54e8d4UL,0xc969833d5UL,0xf554c7911UL,0x3ade9e6b0UL,0x6e1bc3776UL,0x7916948c5UL,0xdbe7ee48cUL,0x79484dca3UL,0xf992e3a70UL,0x884f81b73UL,0xc68777d88UL,0x603ee6fdaUL,0x728b98cb3UL,0xb12701684UL,0xd5f21e414UL,0x58652f15UL,0x2dc8a6e8cUL,0x4767396efUL,0xb8dc549caUL,0xf36b5a61aUL,0xd09ece7dUL,0xdda77175aUL,0x5e9c56d1UL,0x73e7a97c5UL,0xb21f9f9daUL,0xde3c9d2f4UL,0x69504ae32UL,0x77f40c546UL,0xed1217de6UL,0x3a1f88aedUL,0xe623a9a18UL,0xaeec67a8UL,0xbea83aa19UL,0x92eeaf8bbUL,0xa5d08d12eUL,0x819a9bf38UL,0x473d4f6c6UL,0xb192431f5UL,0xa6c92b484UL,0x7046885b5UL,0xb9ab08cf7UL,0x782d94cd9UL,0xf158032faUL,0x77f5e976UL,0x12dda2281UL,0xe72417123UL,0x3056de487UL,0xe3de9931aUL,0xeb3079ea4UL,0xe4420bad6UL,0x439c2e4b6UL,0x47da4a615UL,0xd7cfdda3UL,0x56afc5107UL,0xe978c5f8bUL,0x5aede1266UL,0xaf1b79719UL,0xf8b1b3239UL,0x75e8845dbUL,0xbf1b4b93fUL,0xfd5341b54UL,0xa2373b2d3UL,0x5967e672bUL,0xa2cc66e6dUL,0xb17028581UL,0xb54ad1f24UL,0xe91d22b84UL,0xde85c41f1UL,0x53d588e6fUL,0xe9e407afcUL,0xfc6272bb3UL,0xa8ca0629aUL,0xb86665d04UL,0x5a58fde9UL,0x1855b427eUL,0xaabb42946UL,0xe204ca78dUL,0x32897267bUL,0xa78d7ae2UL,0x96536a598UL,0xbf2aea0a9UL,0xc9bcd56cUL,0x81eb921eaUL,0x2732fe125UL,0x2eb69808dUL,0x61f3bd153UL,0x8ddf0168fUL,0x921d1d7eeUL,0x2bd48ca40UL,0x83ab154b8UL,0x5f436aee4UL,0x93dca0abcUL,0x26d75ad1eUL,0x872a1ba54UL,0x373a9f700UL,0x50d931f63UL,0x12d2f512cUL,0xc6efdbb59UL,0x88e99ed22UL,0x903b7f8acUL,0xa9da1210fUL,0xa2eba3d41UL,0xfe9cd615cUL,0xfb8911731UL,0x1cab3defcUL,0xe6289b02dUL,0x66d6a35b6UL,0xb0096a91aUL,0xc9afcc532UL,0x80aebe5acUL,0xd2f2e9768UL,0xcc67edb56UL,0xa51e37f35UL,0x6ac0eb6c3UL,0x6af2a4aa1UL,0xe76290ecbUL,0x37e738db9UL,0x72d9b11c5UL,0x76e613f46UL,0x4f073278bUL,0xe1eea307UL,0xe9e8f9111UL,0x793ee6f5UL,0x17304e15fUL,0x7a3361104UL,0x731339958UL,0x8daa6a511UL,0xa4037ef6bUL,0x210896f2fUL,0xafc535032UL,0xe3025a0f8UL,0x63e21ba5fUL,0x3ebb5b8c8UL,0xf9c6b06c3UL,0xca95ee37eUL,0x81f852bb4UL,0xd6895d823UL,0x7040cca75UL,0x4d66ec391UL,0x4a216e588UL,0x51d6c18ceUL,0x47711c319UL,0x6ae7f794cUL,0x4abe694d7UL,0xbc96f6f6eUL,0x57aa76cd2UL,0xf948f2648UL,0x31bcd1bc3UL,0x94c7b3f1dUL,0x32eef86acUL,0x668f8ff2eUL,0x6de170ab8UL,0x9341b93e2UL,0x974e1c163UL,0x73182af6dUL,0x5d85fb48bUL,0x78b257bdeUL,0x173d0eb29UL,0x5add785d1UL,0xaf6e83240UL,0xdce79166cUL,0x22716840bUL,0x7b408f1d9UL,0xde43a217eUL,0x36e10fb6eUL,0xea9a83ddfUL,0x4dcf50162UL,0x9aab07a8bUL,0x281364431UL,0x8392dd46eUL,0x945e6aceUL,0x8d07b3a82UL,0xd012f1990UL,0xb7098acc7UL,0xc2fcfa16cUL,0x1e7c731a9UL,0xf16ea68eeUL,0x2fa69cb03UL,0x4cee1f92bUL,0x1e20cfda2UL,0x9e9d1ef4dUL,0xe83358a6dUL,0x59a873d48UL,0xa6842b671UL,0x6885bdbefUL,0x73e4014faUL,0x7b9954840UL,0x548157ffdUL,0x8853a8c5dUL,0xeb8874fe0UL,0xb25d4f257UL,0x36b447da5UL,0x71d87958fUL,0xeedd91553UL,0x4af23612aUL,0x278329eacUL,0x191121b76UL,0x6e691175dUL,0xbd140329UL,0x6ed4532ceUL,0xd5e3c8ff4UL,0xe26c64033UL,0x494a2097bUL,0xf5e36d440UL,0xb7818d202UL,0xa63548c34UL,0x682f0bdfdUL,0x3d3c65c17UL,0x4c4399ae7UL,0x6b18e67ffUL,0x4778211a3UL,0x4089b2dd5UL,0x21edee850UL,0x739cede72UL,0x858dfc744UL,0x4bc5dba6cUL,0x21cbd3bdcUL,0xac83de313UL,0x6135f08daUL,0xd3a3a9f0bUL,0xeb2716099UL,0x40b88e413UL,0x992442a25UL,0xc639de695UL,0x683bcc7c7UL,0x6245fc74fUL,0x543766bd5UL,0x375356569UL,0xfa45b7a88UL,0x9f29b1207UL,0xba245457cUL,0x5b98e5ec9UL,0x204aca6b6UL,0xd52e9605bUL,0x504a40d28UL,0xab6e1695eUL,0xa26481ebbUL,0x9455ec341UL,0x2f05f98e9UL,0xead83365cUL,0xb928d8486UL,0x7b860de0bUL,0x964ef7da2UL,0x2422962b9UL,0x28f5ddfb2UL,0x8c5c63713UL,0x9068c6494UL,0x50aad5744UL,0x93e7cca30UL,0x9825e8b8fUL,0x3a8b4947dUL,0xfa06737b5UL,0xcb9c963e8UL,0x91a2bc332UL,0x284666b59UL,0xceb82a1c8UL,0xa2fe9f06aUL,0x6fa50365UL,0x19aa747faUL,0xa6e117dc2UL,0x2b3810910UL,0xff7e857b2UL,0x48b55c3eUL,0x975456ac2UL,0xad200ed37UL,0xe4d4d86efUL,0xb3ec62491UL,0x8cd465c4eUL,0x8a2be2d94UL,0x5a9f7d648UL,0x59e067a85UL,0xb5c35327eUL,0xc4ca8714eUL,0xe927a04cUL,0xf71eac628UL,0x109354e62UL,0x1037b1a5bUL,0x26c27f893UL,0x3597fa385UL,0xee24b62efUL,0x4b31f921cUL,0x650244e5dUL,0xcfec64526UL,0xcd4bb0a21UL,0x648c56197UL,0xbd95056f8UL,0x983c8c183UL,0xddc662f22UL,0x5631bb980UL,0x1203f56f3UL,0x6a0c37549UL,0xa59baa8a4UL,0x6a23a5068UL,0xad609c354UL,0xf6f6d5e74UL,0x36bc95f79UL,0x424c92c62UL,0x3692abf50UL,0xa4bc460dUL,0x1b4434b89UL,0x4eb31302dUL,0x9a3a891f9UL,0x93af8d5e7UL,0xef60bfa02UL,0x607a378d6UL,0x5a5a7d835UL,0x536c0f467UL,0x11f66a7feUL,0x74c7c43c5UL,0x66eae7c29UL,0xf5a785d2cUL,0xd3948a5c0UL,0xec1094aa4UL,0xfcad61c19UL,0x49ca7108aUL,0x77437f4b6UL,0x553083d4aUL,0x5c26c14cdUL,0x6eb4caceeUL,0xe8aded63cUL,0x132aa4b5cUL,0x57603a19eUL,0xee359dda3UL,0xd0f5ea330UL,0x46b0f0b1fUL,0xd47cbfc81UL,0x3ed1b37b0UL,0x4c8c752d8UL,0xac202044bUL,0x207f16128UL,0x53f5c3981UL,0x70e1a33a2UL,0xed8348baaUL,0x798f94a3eUL,0x8896c890eUL,0x521425a3fUL,0xc8329e9eaUL,0x41f238ba5UL,0x1093d3c81UL,0xcab628e90UL,0xa1b4bf356UL,0x92eee2fceUL,0x59d35b9afUL,0x2176e9f53UL,0x7c9abfb89UL,0xb06d107e9UL,0xe94c318d5UL,0x2f397ae30UL,0xd7e5a1a48UL,0x98c4abc47UL,0x574737c29UL,0xd7f5401b2UL,0x852b87bc6UL,0x1180fa957UL,0x501c63328UL,0xfd28c0d13UL,0xf764aa079UL,0xc8a6f8c5aUL,0x975b10240UL,0x6bd33e4c0UL,0xa1113e39cUL,0xabcfa8fb8UL,0x149ea1facUL,0xf6443556fUL,0x959da07e7UL,0x4721a2ac4UL,0x30bde0f15UL,0xc7c4fdef8UL,0xb7feb4465UL,0x56675073cUL,0x96f3f57b9UL,0x876f0386eUL,0x393f0a7e8UL,0x32b40ebd6UL,0x10a11346aUL,0xfb81f48aeUL,0xa892877eUL,0x86f636e08UL,0x4fbc4d72bUL,0x561d5f314UL,0xca18e2835UL,0x7e6f519f5UL,0x8b94e7983UL,0x619adfaf3UL,0x4c9ddbbabUL,0xcb6a461f2UL,0xf6e22456UL,0x858c9b401UL,0x92dc1b3b8UL,0x3a783615bUL,0xc74b66f67UL,0xea90891bcUL,0x31a829e4bUL,0x7bd38f505UL,0xb4476ea80UL,0x1af371feaUL,0x84894ff56UL,0x537584dfUL,0xd4ebdd1d0UL,0xb43cc192bUL,0x76700d287UL,0xaaad9fa58UL,0xfa511710fUL,0x6e54699e5UL,0x6d73391aeUL,0x3c2f1fb49UL,0x4fbd96a75UL,0x252e6304bUL,0xe72826214UL,0x8fe6c9336UL,0x326397743UL,0xe03bc524UL,0xdedac9594UL,0x4ff19096UL,0x409b4cdbbUL,0xb15921888UL,0xa259bcd6dUL,0x43c67f305UL,0x1dc65dcecUL,0x1730b4f85UL,0xf8a48f16aUL,0x57a30e743UL,0x5afd9839UL,0x682d5f3aeUL,0xb694337eUL,0x758c7dacfUL,0x18fa1ae7dUL,0x5ba9b5984UL,0x32e1d45ddUL,0x672f05518UL,0x382ffc5b1UL,0x8f0b08f33UL,0xb4a4d9ff0UL,0x53ba0f980UL,0x2ac0751fbUL,0xab005de73UL,0x61ab7be9bUL,0x63078c9adUL,0x27659d148UL,0xc653c684fUL,0xecee05017UL,0x24378ce5eUL,0xd0f7e5bacUL,0x8b4bf4199UL,0xb7aa495fbUL,0xf3d6b78a5UL,0x98bab1024UL,0x6b4971fadUL,0x723d6c89UL,0xa17071a75UL,0xd55a301f4UL,0x988de925bUL,0x7ca276f45UL,0x321b6e484UL,0x316149ed6UL,0xb8dba5bb9UL,0xaad4df3f4UL,0x178e204f5UL,0x95cd2e357UL,0x73fb8a733UL,0x84ca10c86UL,0x89498492dUL,0x5b9bdf383UL,0x66c58bb10UL,0xf153ac21eUL,0x7ca5d3b04UL,0x637a521c7UL,0xb5ed589c1UL,0xd0a3c644eUL,0x3d5d0754fUL,0xc6b901174UL,0x3e96fd3edUL,0x79c2fdf8cUL,0x6594ae371UL,0x3504fd77aUL,0x32b81dcc7UL,0x57b4f3e35UL,0x4c9808072UL,0xa06c10993UL,0xb059666afUL,0x72b69c034UL,0xe33ae836eUL,0xad6cadf0dUL,0x19573ace1UL,0xd562fd1e7UL,0x847804d9dUL,0x9e32f6734UL,0x2355c580fUL,0x2f177b8d6UL,0xd689ac650UL,0x71b70abcUL,0x254915730UL,0xc5934f949UL,0x134d59d09UL,0x2c731fb06UL,0xd90c6c5cbUL,0xcc3f9bca4UL,0xbf078980cUL,0x80838e95aUL,0x5ccd6f054UL,0x378bae56UL,0x8d1ddb978UL,0x93b875cf4UL,0xe2ce90bc6UL,0xec291b91bUL,0xd0a11bdc1UL,0x751be7244UL,0x579fcd29eUL,0xf76e5ccb1UL,0xeb33da184UL,0xc0ac75b0fUL,0x15454fb33UL,0x8b92a411cUL,0x7da34b476UL,0x4f413d45eUL,0x10ec1dbeaUL,0x650739b93UL,0x315e08a31UL,0xd4fd5f1bdUL,0xb5058a126UL,0x20d5cb63bUL,0xc1598dfe7UL,0xa0a2a338dUL,0xe29af7686UL,0x83fd0cac9UL,0x14a8094d8UL,0x816e0afa3UL,0x499ef5d2cUL,0xbddbd0d95UL,0xa30839ca9UL,0x4fd33fb4cUL,0xef63557b7UL,0x535f06ab2UL,0xd47d352eUL,0xa371e6dc4UL,0x8ac914b17UL,0x6ba9d69d7UL,0x96da89aaUL,0x65bbd5d14UL,0xd41d2c5c4UL,0x52a283583UL,0x4c1f56d26UL,0x86cd9984aUL,0x26cbcedc6UL,0x1aa0eaa03UL,0xb95d5ad2cUL,0xe2eb56b20UL,0xff49d9d5cUL,0xcce338378UL,0x330e9fac7UL,0xe2f53974aUL,0x668d1c6d5UL,0xeca0ba751UL,0x8d48ab5e6UL,0xd205e18cdUL,0x1c391633cUL,0xef5d02e5fUL,0xd12bb5f20UL,0x323215199UL,0x88f5b3ffcUL,0x931445f29UL,0xb893cb727UL,0x32851ecc0UL,0x80b44d81bUL,0x5aa48da98UL,0x46d1e1284UL,0x4c837ba14UL,0xeb22c26deUL,0xe51e9d246UL,0x8d03deee6UL,0x5af8e0909UL,0xbde9773a4UL,0xbf611cabfUL,0xd24ac96e7UL,0x9fe919318UL,0x50d0206a6UL,0xb43b9741cUL,0xba48d4fb3UL,0x6bccd7290UL,0x8bc6bfb9cUL,0xe5a036c9fUL,0xa80a2cfeeUL,0xc193655a7UL,0x7c8e5170dUL,0x6141edbbbUL,0x4d6b990dcUL,0xcc49b5702UL,0x2343fef58UL,0xd50cb593cUL,0x4248a60cdUL,0x901cfbd4cUL,0x64a4c8736UL,0x1b2dcbaeaUL,0xd691e5f4cUL,0xdf352a493UL,0x1991ac7daUL,0x4c4879f45UL,0x9b34aadeeUL,0x52bb3db0dUL,0x7b9a8c9d3UL,0xd7ce6e47eUL,0xec0b922d8UL,0x8079cab6bUL,0xabadc8899UL,0xf57b93b7UL,0x5c4ef219UL,0xd7a438d49UL,0xf55ecca97UL,0xd07899f1dUL,0x260947d6cUL,0xffbd21ab6UL,0xd04ff923eUL,0x964b72033UL,0x31ac3fd7eUL,0xd2c52e2c4UL,0x799a640efUL,0x98dd061edUL,0x5cb2ab7b8UL,0x72f3881c8UL,0xe65ed1164UL,0x34fa0bd5bUL,0x64f9823cdUL,0x3797e1ac0UL,0x2fb8a4751UL,0x6f347342eUL,0x22dd7ea0aUL,0xb19b65e57UL,0x44fe83e8aUL,0x7732732eUL,0x64de20ed7UL,0x6c9ea834UL,0x8ce066650UL,0xc2a685ff0UL,0x64f19b01fUL,0x491ab8a88UL,0x41212fe5aUL,0x6f9916f3bUL,0x694f72e71UL,0xad7a5b35eUL,0xf62795292UL,0xc8cdc3d3aUL,0xfbc6b3518UL,0x67b631901UL,0x5b5ba79d5UL,0xf4fadebddUL,0xac7c802e7UL,0x385712d9dUL,0x64bd375b4UL,0xc9a11df70UL,0x88355bf31UL,0x606ffbb0aUL,0xbda93c2d5UL,0x7c5f94f0aUL,0x76fe26501UL,0x5d8b9153cUL,0x886bbb218UL,0xacee2fecaUL,0x2ad19a925UL,0x83b97855cUL,0xd36608312UL,0x8ac60dbc7UL,0x885c8f58UL,0x8abbdf891UL,0xea1602271UL,0xad654fee1UL,0x6c461195eUL,0x5eeb1a327UL,0x18d743962UL,0x1fc7c55a5UL,0xaba749670UL,0x9c9a59c60UL,0x6e5bafc06UL,0x96977db12UL,0xa97b6ebfaUL,0x63d2d9da6UL,0xfab00cd60UL,0xd7bdf4632UL,0xf83878d59UL,0xb1c2c462eUL,0x14e5144a7UL,0xf4a909b28UL,0xe979a185bUL,0x908090a64UL,0x99eccd798UL,0x348780a96UL,0xfdc7ad169UL,0xa600c2e5bUL,0xb0968cd98UL,0x1a45ec098UL,0x99118c1b4UL,0x8afa5cd5aUL,0x1db7e655eUL,0x9f637e452UL,0x9568504e3UL,0x45b2a662UL,0xf2a1455a2UL,0x6c1ca9e75UL,0x30a4a4639UL,0xc6c2c1a30UL,0x87500b452UL,0x5e338bb2eUL,0xd9dd11dffUL,0x8c4b5d012UL,0x8191194e0UL,0xdd11db867UL,0xc67c151ceUL,0x5cb1a00e4UL,0x98b7a1c6UL,0x369f35cd4UL,0xca2190bdbUL,0x6e14bb3b9UL,0x8d5692f8cUL,0xca4b2f4f8UL,0x787f06877UL,0x8acbb8550UL,0x535f4b56aUL,0xf4caf7ecbUL,0xd4615b258UL,0x347ca7070UL,0x3c798c85dUL,0x460506465UL,0x870d0a5dcUL,0x6510b2464UL,0xd1dba5544UL,0xd57789a33UL,0xe2417c5baUL,0xb5ff8628cUL,0xa3bb22787UL,0xa16b64f34UL,0x421e81d3dUL,0x35b4596a7UL,0x8d7a2dd7eUL,0x50b2d83faUL,0x9ea87e7c2UL,0xd5055e752UL,0xf96aa9da5UL,0xb096e2a07UL,0x49970b44bUL,0x867fb1518UL,0x5d0f5dba2UL,0x1b191d11eUL,0x8e839bb8fUL,0x1cd4aca15UL,0x971ec5615UL,0x7d72a7ebdUL,0x8b1253bfbUL,0xe11de1d25UL,0xa7566839UL,0xf4f3542e0UL,0x1ea791e32UL,0x32a84f759UL,0x646f1844eUL,0x42af26809UL,0x1f4b464ffUL,0xda684d2d9UL,0xd854f5fb9UL,0x4d4d3e91aUL,0x5af3ef4e2UL,0x8a1ef5ce7UL,0x2354febf3UL,0xb3c5a8944UL,0x98b62a144UL,0x9bdba0b4eUL,0x4aa99b42UL,0x8099ea151UL,0x2185463a3UL,0xb0a1ae997UL,0xe628d5770UL,0xb40b5ac89UL,0x27213b17dUL,0x4d21db5b5UL,0x10d0748f7UL,0x2276c7876UL,0xb98bee56dUL,0xbd1ca6ae8UL,0x824ab48faUL,0xc6f35ae62UL,0x3547a563cUL,0xf1fc0d824UL,0x58f55ed75UL,0xaa9d0de01UL,0x4719dde60UL,0xd5386b3ddUL,0x4d8d9f666UL,0xaee36013bUL,0xba4ee322fUL,0x898d2db4eUL,0x9fe364808UL,0xbb13e8045UL,0xbe346d43aUL,0xb4c9f886fUL,0xc9a6f53b8UL,0xed5a7b6fUL,0x2a1fac740UL,0xb8c134a59UL,0xb1f773993UL,0xc4d9d0025UL,0xca905bdcaUL,0x3150a39a7UL,0xe8329fad5UL,0xbd4f98059UL,0x3bc5cf6cdUL,0xc982fdd03UL,0xa372de28UL,0x73fe2e35aUL,0xb9f684ecUL,0xc543ff680UL,0x1bcf5f09aUL,0x51b2a8099UL,0xee53277c2UL,0xb3835a6cUL,0xaed6765c1UL,0x92cfd64c8UL,0xd20c60ed2UL,0x59dbd9f51UL,0xb6acb694bUL,0x427dcd5fdUL,0x646336a75UL,0x8008dea4dUL,0xaf2bdc7cUL,0xb8a46478aUL,0xb02c535b6UL,0xc645d8631UL,0x44b4af3dUL,0xc9edfe6cbUL,0x32ac8ea2aUL,0x79266a23fUL,0xc2d902e93UL,0x6ae5cfbdbUL,0x2c66c633eUL,0xeb7a8a4e3UL,0xcb17281cfUL,0x7ca378680UL,0x7ac81509dUL,0xa59a05073UL,0xc9cb9f18dUL,0xb78100d29UL,0xfab49420aUL,0xd0a4e69c4UL,0xd6c33f722UL,0x68d21bff8UL,0x1fdad8ca3UL,0x2884d6968UL,0xb091ff264UL,0xeb5fb236fUL,0xa3d2a1839UL,0x527db0bc8UL,0x2dc68cd9fUL,0xe3f4ea98aUL,0xa629fe44fUL,0xb73bd7d66UL,0x2abfd7b6bUL,0x1b4056054UL,0xd6efaac28UL,0xd13cc950UL,0xef84ead94UL,0x5b6ee0d50UL,0xf4bec692UL,0xde1b98881UL,0x55ccccd31UL,0x86d9b84dUL,0x5ab736e3dUL,0x167d2f005UL,0x118ed1522UL,0x38bbdc903UL,0x39cd31ac2UL,0x31091bc51UL,0xd66a87d3fUL,0xafdade6d3UL,0x2bd1fe097UL,0x5cf545dd2UL,0x5e0af578eUL,0x6fe6dd4c9UL,0x862bc8fcaUL,0xcbce0b4c6UL,0x8b7fa8ddUL,0x3d108ae9fUL,0xfed2d914aUL,0xbab304bd8UL,0xdebe74f8dUL,0x1e857e3dcUL,0x570340581UL,0x114bbf4f5UL,0xa3cfc0566UL,0x4026cd686UL,0x266fb76cdUL,0xb715773bbUL,0x2fd2785fdUL,0x481b34cadUL,0x11c58d2baUL,0x3a5186f4dUL,0xda55ab71cUL,0xac887db92UL,0x9bd6d5592UL,0x45857d12aUL,0x8c862f0b9UL,0x870c88666UL,0x4a4f4901fUL,0x774a993d0UL,0xc9f16c81dUL,0xeb415e9efUL,0x307aa6302UL,0xa246f21eeUL,0x1a4f8a9c2UL,0xcf09f9b4UL,0xdb30dbb49UL,0x3581be36fUL,0x6919a4318UL,0x8ee677afdUL,0x5944b9d59UL,0x8d5fe61aaUL,0x77c174b1dUL,0x5cff8fa10UL,0xc1ce82f48UL,0x7fbb18e65UL,0xb6737103UL,0xe2d30a9b6UL,0x6481ff469UL,0x5834b4d26UL,0x3bba517d5UL,0xeee6e8080UL,0x5fe4fea5eUL,0xe84e94c8cUL,0xba2ad0a2aUL,0xa7f2aead0UL,0x63cecb46dUL,0x8943d7229UL,0x1d3878b2bUL,0xf2b4efe94UL,0xd9af1949dUL,0xbb5824d39UL,0xb8d8f5090UL,0xed5e19d08UL,0x60287437eUL,0x8fe6ae5c2UL,0x6c85ac058UL,0xb906be1b8UL,0xf9d423f65UL,0x6efed81d6UL,0x781b67fa2UL,0xe1dd437acUL,0x7a9201a8cUL,0xfb444c819UL,0xce75af959UL,0x86df6e72bUL,0x756695aa7UL,0xb7b2bddf2UL,0xf19a1b99eUL,0x9a5790e90UL,0x1d3b3eac0UL,0xa5c5d9d2bUL,0x152850218UL,0x25c4ba6eUL,0xd4a5f4bebUL,0x709cec10eUL,0x94ddbdb6cUL,0x9d1218277UL,0x6190ca34aUL,0x468ed6a3fUL,0x801bda52eUL,0x261b3f1a9UL,0xb3494d9bUL,0x583e2d7e5UL,0x9407a80f2UL,0x58e902456UL,0x9108c2273UL,0x59778ff8cUL,0xd6ce05028UL,0x286adc62UL,0x7ed3060dcUL,0x57b7e03edUL,0x3e3dce5c1UL,0x1bebc2295UL,0x14a17c9aUL,0xc7d90fbdaUL,0x8158ae35aUL,0x69d70a335UL,0xd3ef97931UL,0x5793efb7aUL,0xe6989ef43UL,0xcd15f0116UL,0xf9dbc6e25UL,0xda4a91117UL,0x54d0917aUL,0x60f2c3f15UL,0x7393b0a66UL,0x6630ed79bUL,0xed8589c60UL,0x7db37ab26UL,0xc4631e80aUL,0x1badaf501UL,0x9bdef764dUL,0xdd0949b4bUL,0x86f116771UL,0xacd7ea109UL,0x7cc9d2f6bUL,0x3f5598822UL,0x4ba5a8d0cUL,0x66e7f9c42UL,0x33127fb36UL,0xc85ff976UL,0x9dbb32ddfUL,0x3d06c7a56UL,0xac07601ddUL,0x5fda3d7e9UL,0x40a47aef0UL,0x139928cd0UL,0x183ab75ebUL,0x9dd6d1f4bUL,0x954afec44UL,0x29953fe22UL,0xf947e49b1UL,0xa74266cb0UL,0x3bbb7fdabUL,0x8a72b63d1UL,0x8763e2fbbUL,0x8c9b4f9a2UL,0xa35f5a861UL,0x99e54752cUL,0x2fdb8e16fUL,0x2d083ed68UL,0xa05d36c5eUL,0x5460842feUL,0x173ae0ee6UL,0x38b3c62e5UL,0x476c1ae99UL,0x9a8cb898aUL,0x19d4032acUL,0xa9c01d80bUL,0xca7d5e4deUL,0x295d53115UL,0xb26740e51UL,0xbf21b0988UL,0x167391c15UL,0xd10af35c6UL,0xd94750799UL,0xcb986d117UL,0x1dddf588UL,0x71ed85f46UL,0xa5437d58fUL,0x4029d1e25UL,0xc580ec972UL,0x6847df8baUL,0xe294d997bUL,0xe2e8b10eeUL,0x1593103ddUL,0x222103857UL,0x1e035591dUL,0xb5c9ef2e9UL,0x9f815ec3eUL,0xd1da2a021UL,0x54f171191UL,0xe51f4a05eUL,0xc15e7d603UL,0xba7f16b87UL,0x80b7a83e1UL,0x720e2b18dUL,0x5ec0c069dUL,0xa4f9f689cUL,0x5871cafdaUL,0xc913140a2UL,0x7a8f2efd1UL,0x77064952cUL,0x4ea2d857fUL,0x484523555UL,0x54971a9e3UL,0xeb0694eb2UL,0xb513c8e63UL,0x5c910db58UL,0xca87a4dd7UL,0xb8ca63158UL,0xb4b09431dUL,0x3dc9d50b7UL,0x7d57f02acUL,0x5c595b1b2UL,0x9e0caf698UL,0x136b48555UL,0x687dbcc2bUL,0x54bae2294UL,0x6899bbd7bUL,0x8108f46deUL,0x1dbe8cf08UL,0xa02e1ae1dUL,0xf5f26d59UL,0x805cf202bUL,0xafede5687UL,0x1583d5b30UL,0xda9ed0620UL,0xcf1237338UL,0x3a5a77bc4UL,0xa17ffa0c6UL,0x29de4c387UL,0x7825d431UL,0x2d7b9b38UL,0x8ed0f26aaUL,0x56e54e30dUL,0x9620ab0e7UL,0xc7e3ea94cUL,0xd288a41e2UL,0xf68884f1eUL,0x5ee02df09UL,0xc02dbf645UL,0xeac4c2424UL,0xcab2d51e1UL,0x37439577UL,0x5618ada43UL,0x2683b5859UL,0x8a607c1ceUL,0x795fd9198UL,0xb3edb11b8UL,0x846939c5cUL,0x8b1f6fa23UL,0xb1a2f2bfeUL,0xb63a07ad7UL,0x5f8ea7b00UL,0x4ee9c6d0cUL,0x990f2889bUL,0xb7f7251d0UL,0xac3291369UL,0x9d8f36a7bUL,0xd57342897UL,0xefca98365UL,0xdacc69f0eUL,0x3a70e4b3cUL,0x1e95c34c2UL,0x4caab6c06UL,0x7231f6ee1UL,0x37909aa04UL,0x48c9a9ccUL,0x59cd081bcUL,0x4dd78c2e4UL,0x4979da10fUL,0x4749d0c5UL,0xa17a4283bUL,0xde7e1d52dUL,0xe47cedf1UL,0x4fa48cbffUL,0x545a932a0UL,0x6c2bd9eb8UL,0xdd9bd3b8cUL,0x43332c1baUL,0x501fa761dUL,0x7ec40adbbUL,0x4049f2b33UL,0xcde28f57bUL,0xf68c804b9UL,0x8f50fbd3eUL,0x54e1bc344UL,0x36b26e3a2UL,0x2e5ac9b1UL,0x10837858dUL,0x6ccac9e0bUL,0x625ba8a52UL,0xac4c8b45cUL,0x868678237UL,0x4187235feUL,0xbd62663ceUL,0xea832dfb2UL,0xd5a72f0a7UL,0x659c855eUL,0xbea7f5e48UL,0xff9566715UL,0x1bd06d99aUL,0x9666c578cUL,0xc6527d3ecUL,0xb541f3c61UL,0x678a9ad70UL,0x36eaadfa3UL,0xaf74b01deUL,0x54cc3cdc3UL,0xd2e587ce6UL,0x8694b9349UL,0xd309898feUL,0x5c3250e09UL,0x84dcac28eUL,0xf72add2dfUL,0x1901681a3UL,0x9e6a8fd4UL,0x12f614cd1UL,0x6d7801ac4UL,0x14cf1ca54UL,0x12a7eb608UL,0x5e7a3bf62UL,0xba5056a2UL,0x5bee44c9bUL,0x819d7dc86UL,0x62adc8fdUL,0xbd3155d41UL,0xcd8c6b38aUL,0xe320fd50eUL,0xe189d6655UL,0x6863c2831UL,0xd2b9058fUL,0x23bfad8faUL,0x199bd1216UL,0x56138afd7UL,0xface83a93UL,0x9554da725UL,0x9b614dd91UL,0x98acbca3fUL,0xd5f0d5f21UL,0xeb59039e1UL,0x51d1ec82aUL,0xa366ef3baUL,0x1ad0e01f0UL,0x7f038ad0bUL,0x3ee055321UL,0x3bf2dcbb7UL,0x210e9856cUL,0xe4fea8231UL,0xb89444937UL,0x58852cc34UL,0x1ee29eea9UL,0xb919c79f2UL,0xddc44d3adUL,0xddcbd4777UL,0x3c3982ba1UL,0xdc8ebc45dUL,0x8b97712b1UL,0x9702ea21eUL,0x1f457e726UL,0x27c6f6e26UL,0xa9797770UL,0xd7615f53bUL,0x74f1cb6e1UL,0xa32e4d7dcUL,0x2e89afd1dUL,0xb03704d5UL,0xcca58aab0UL,0x1e5749225UL,0x6e63a36baUL,0x562992099UL,0x64701b950UL,0xf94ed6196UL,0xb3441b5f1UL,0xc64fac247UL,0xd72ebd98bUL,0xfa1985b23UL,0x2df788358UL,0x88838b488UL,0x6091032b4UL,0x25ff2d736UL,0xdce63d3d5UL,0xbb5970414UL,0x44d8b5ffeUL,0xe1a5666d8UL,0xe34129125UL,0xe23854b1UL,0x1b2a6dbeUL,0xd11507bcdUL,0x844531e6bUL,0xd864a8611UL,0xe2a5a7700UL,0x2d178962aUL,0x156b07f01UL,0x48b59fec3UL,0x3d3d9d79cUL,0x1846fb339UL,0xddf1d03caUL,0x998abaf9UL,0xc9d76190bUL,0x67354a1a8UL,0xcc89e2b09UL,0x353356834UL,0x7ad97470eUL,0xf4d560524UL,0x534b7804eUL,0x14290c632UL,0xb67d39d60UL,0x35b166febUL,0x88e6fb681UL,0xa0f82ae1aUL,0x8460ce52UL,0x8b06a9012UL,0xdaf1299dcUL,0x629ab696cUL,0x3113b448aUL,0xdb5ca215UL,0x3e00b1e2dUL,0x85a87f5abUL,0xb3995ff20UL,0x85661554dUL,0xe709c5384UL,0x111ca99bUL,0x49e614279UL,0xf14677ec4UL,0x8f6439bfbUL,0x749faa461UL,0x1c4f9189aUL,0xe8e9015caUL,0xf6e68d510UL,0xb3819319fUL,0xda9f7119fUL,0x7787f40f8UL,0xbc57f5716UL,0x60ff2897eUL,0xb3a28a934UL,0x10b34c97cUL,0xc14f53aedUL,0xd3c4eaf5dUL,0xb3148d39eUL,0x7874ea02UL,0xf86692b4aUL,0x5b03a0e8dUL,0xce6db8cc6UL,0x8233d5908UL,0xf163e3c06UL,0xdff854cceUL,0x26706f1bcUL,0x94c358653UL,0x7384c9821UL,0xe51b8e5d5UL,0xeda32963bUL,0xa073f392fUL,0xc3ccfa213UL,0x34adf5216UL,0xcb8da286bUL,0x3b5fbbf08UL,0x12812d1f8UL,0xc97c54c39UL,0xe1c3e36b9UL,0xabb8dc0edUL,0x19dcbbf6UL,0x25b0d7c4dUL,0x45e6b5ceUL,0x17dc086caUL,0xc3f425e6bUL,0x6fdee14f8UL,0x39155e6b4UL,0xa191ec15UL,0x398fcd7f4UL,0xa6e2b0594UL,0xfe5678d82UL,0xe317eba1fUL,0x2c4f10ca1UL,0xae239c19eUL,0x18e663ed2UL,0x4a040b7e7UL,0xbbca0849cUL,0xce05b3a74UL,0x7cee982fdUL,0x78ee54fa7UL,0x7b47bb0bdUL,0x7e8f19216UL,0xd67d91cedUL,0xef5effe94UL,0xec1d1938dUL,0x4c05ef70eUL,0x324442d9UL,0xfb0183bb4UL,0xfb7a0bd50UL,0x89aa17d87UL,0xe4e6aed89UL,0xdbecf68b4UL,0x683770de4UL,0xb9f41a136UL,0xc7614caceUL,0x89c298386UL,0x959cf09deUL,0xab30b19e3UL,0xdb2e4b614UL,0x26d30d39bUL,0x6ccefe452UL,0x587c5035cUL,0xea73bbbe0UL,0xdd9d91a11UL,0xdd8c5e851UL,0xe8b4aa077UL,0x8ccf8faddUL,0x47ddd3c0bUL,0x635a92f19UL,0xf0edfd1a3UL,0x1f760bf5eUL,0xa83feb68aUL,0x4f74da9ddUL,0x52f759252UL,0x98bee689eUL,0xc5fc8c3d5UL,0x8373d1286UL,0xf5f1cdabdUL,0xada68d3e5UL,0x3bbb9eb5eUL,0x50cde8478UL,0xf01f956e0UL,0xa922f2842UL,0x233a8b25aUL,0x71118b754UL,0xb7f874552UL,0x44d757121UL,0xb873b14ccUL,0x5bcc1db5cUL,0xbf9b895ceUL,0x5e65bb620UL,0xbbd1ed35cUL,0x358e79973UL,0x62aa5a4a5UL,0x81715fc0fUL,0x8df03a76eUL,0x376b7c6c7UL,0xa07a49f2eUL,0x45e159b63UL,0xdae5706b0UL,0xb5e52c7ccUL,0x206935e8eUL,0x39f0c5119UL,0x3cd58c574UL,0x571986d35UL,0xad66da60fUL,0x2b1a6315UL,0xd0131b533UL,0x741a195c5UL,0xb8663437UL,0x1cde52798UL,0x6b8e658b1UL,0xb43c0d44dUL,0x45481d697UL,0x29de93df5UL,0x10549b874UL,0xc056b5828UL,0x3fa830adUL,0x9496d14faUL,0xf540592a0UL,0xf31c8b855UL,0x64f2ba36bUL,0xfe7c6e4f5UL,0x5e42a78b0UL,0x9c2b8b096UL,0xdcb4a6e71UL,0xd63b0e7edUL,0xde1bcbcdaUL,0x68e7161f2UL,0x3e5ddf88dUL,0x419a37501UL,0xfad63e7abUL,0xc6e81b4baUL,0x8329315d3UL,0xc88d267e6UL,0x73a0ac25fUL,0xe7b75690fUL,0xdcbb95be2UL,0x7a1d2a059UL,0xd8fac361eUL,0x6312ff5c9UL,0xd2cf50d54UL,0x8c65fd00fUL,0xaa1636532UL,0x870c7285dUL,0x1894f0b84UL,0x4260cc5c3UL,0xe9997b9ecUL,0x87a052144UL,0x8706babf6UL,0xbd5f62ad3UL,0x1a7895439UL,0xf7e294bbcUL,0xbcc27ca26UL,0x3186a63d4UL,0x7f3ede4a4UL,0xb64e32468UL,0x71f250d53UL,0x7c6513783UL,0xb1778714aUL,0x94bf2c57fUL,0x64a9f893aUL,0x1305be654UL,0x493e0c9f6UL,0x5ba6fed8UL,0xc4a0c7a06UL,0xcc2ec0ddUL,0xd9a6769afUL,0x724c78a49UL,0xc85c981a4UL,0x12553c4cdUL,0x83cb892b1UL,0xbc324ccc7UL,0xef43f6c1dUL,0x2d6748bb7UL,0x5efdce2d7UL,0x94af64f28UL,0xf9d58feb3UL,0xcf547ac63UL,0xceb309febUL,0x30beba8caUL,0x8ab2e486aUL,0x4a95d58adUL,0x25ce07c46UL,0x712b93fd7UL,0x7f46acc81UL,0x64049d4beUL,0x65303aa09UL,0xf3aad21b3UL,0x2903a6cd0UL,0x5a0e0467dUL,0x3c4fa64e4UL,0x5c6655126UL,0xb40a2a67fUL,0xb0c22c6e5UL,0x1507e039bUL,0xb282b16b8UL,0xc0e14a3d3UL,0x93d381427UL,0x6bb55bb87UL,0xb675af72fUL,0xfceb4f95eUL,0x66af6ebbdUL,0x20a44d1f2UL,0x6bc873916UL,0xb8947bee8UL,0x4b6bed8a6UL,0x7012f7867UL,0x7eda3c150UL,0xab3ef1b8eUL,0x6d71466eeUL,0x408c4e225UL,0xe117838b1UL,0xaef3a075UL,0x5a0779d4fUL,0x70a3b1d69UL,0x26ccd31fdUL,0xed64dd1b2UL,0x981d4f60cUL,0x6a6e4fb61UL,0x52f15fc93UL,0x32b3a64dUL,0xecb17d667UL,0xa983fb935UL,0x37d23c88dUL,0xb8590fbcbUL,0xec2f1a277UL,0x90d3053e6UL,0xa36fa8ccdUL,0x44bd08eccUL,0x61dd197d9UL,0xa307cfd82UL,0x1d09c2de4UL,0x5f6d74368UL,0x1327d1b2dUL,0x594cc36b9UL,0xfea1cba7cUL,0x50c31262dUL,0xd99b1a6baUL,0x1bf789cd2UL,0xe2f6f66f9UL,0x13d5edfc6UL,0xbc3a9ab0cUL,0x1da5b2734UL,0x25ef4f2deUL,0xdcb55a50aUL,0x9c6dbc6acUL,0x89a838853UL,0x168f099eeUL,0xd51601760UL,0x89f324f1aUL,0x2cb1ec1eaUL,0x6306de366UL,0x12a2f11eUL,0xb5c0bf797UL,0x5c5f02be4UL,0x5019f54beUL,0x6ae4a096aUL,0x4bce78778UL,0x94b65b97fUL,0xd3f6e7bd2UL,0x1fbd2a84cUL,0x6d0127ab1UL,0x3e82799aaUL,0x4c1264dfeUL,0xcf69c9360UL,0x4b43e5342UL,0x35d1f0372UL,0xd78c18eb4UL,0x262574101UL,0xc2c5c7335UL,0xbad04051aUL,0x1c481f94eUL,0x3285aa0deUL,0x8973e1f69UL,0x5d238c694UL,0x7b71847b9UL,0x242f5675cUL,0xcc5751c2dUL,0xe09bc620bUL,0xe4e904ddUL,0x7ca4f1a7UL,0x2ac79ae43UL,0xe213d4250UL,0xd4137c2b5UL,0xddfce11bcUL,0xd1d658566UL,0x213f5b1bbUL,0xcd35be0a8UL,0xcc67d7f91UL,0x509bde098UL,0x74d3d8f46UL,0x51309c970UL,0x53e2bdf66UL,0xa5dd3fed3UL,0xa4e69b212UL,0xb1d39936dUL,0x6b6c8926bUL,0x46540a7b0UL,0x2eebc599fUL,0x2e54a283eUL,0xf9a328a9cUL,0x7ea9cfc53UL,0x5cffa2bdbUL,0x464d16f8eUL,0xeb09444bcUL,0x3f341b259UL,0x4d112b108UL,0x70cb94242UL,0x974ed4ffdUL,0x1084da291UL,0x85673ca39UL,0xd4d74766fUL,0x64a68e1deUL,0xe35630caeUL,0x2073229dbUL,0x63d3a3902UL,0x31598ee06UL,0x808d61126UL,0x29957984UL,0xd4f5f2649UL,0x9ec8a706bUL,0x349981760UL,0xc93ab23a6UL,0x2c7aa80daUL,0x866f102baUL,0xb15cff7bcUL,0x66a13a4caUL,0x54a755048UL,0xd13fdb8d9UL,0x16ad5edf3UL,0xe043bb154UL,0xcc8755671UL,0xcf9b2bfd5UL,0x3608890b4UL,0x330fef315UL,0xe3299ca65UL,0xb60765e1UL,0xe9bb17dcUL,0x95f474d8bUL,0xe721d3d00UL,0xd4679e565UL,0xc80da6113UL,0x98deeff30UL,0xc293bb871UL,0xe79132f48UL,0xb152dafbbUL,0x55f6a4386UL,0xa1b8a4044UL,0x4f4187b05UL,0xb17c2ed3UL,0x95d75ba04UL,0xbbf12e96dUL,0x6abd1a52fUL,0xf300bc991UL,0xf0a7385d4UL,0x52964f82aUL,0xa9962925fUL,0x613b2eef1UL,0x5fd2c92a8UL,0x9ebecd05UL,0x36002b87aUL,0x902c79eefUL,0x394e63c7eUL,0x133285064UL,0xf7cfe2d4bUL,0x4f068522cUL,0x96fea1a0fUL,0xc5a927b13UL,0xe9a2c1994UL,0x5c53b3803UL,0xf636b6188UL,0x7c656e3UL,0x26af1fc5fUL,0xec2f40b78UL,0xfaa1921e5UL,0x6137a8b30UL,0x28674f7bUL,0x3de184e35UL,0xeeef093e6UL,0xd44b3dae0UL,0xbb7ab7d93UL,0x2ae18c956UL,0xcde492bd6UL,0x1cee0216eUL,0xf1e5830adUL,0x76f6c3299UL,0xdea24af84UL,0x277e75586UL,0xa17318024UL,0x5c4739486UL,0x5e3de4725UL,0x6f67c9f6dUL,0x25f42791dUL,0x3c54d15b3UL,0xef98d9c32UL,0x42f64819dUL,0x16d5fd070UL,0x63cb98d4fUL,0x45a3ad27cUL,0x1b496b0acUL,0xaa471c42dUL,0x599346a2UL,0xdc8d1c2dUL,0x7498928c1UL,0xea06e90ffUL,0xb683baa32UL,0xf93014e16UL,0x20575d56eUL,0x794325589UL,0x1533e9935UL,0x86b8bcb70UL,0xce11faf5dUL,0x36c0bd318UL,0xe5e8c1167UL,0xe1831ba64UL,0xe088dbfa4UL,0x984479674UL,0xafef02b29UL,0x48518c716UL,0x4301564ceUL,0x21cc88710UL,0xd5c995278UL,0xd8367de1cUL,0x4a51125e8UL,0x113e1c226UL,0xef141e076UL,0x44097011dUL,0x4ca9d707cUL,0x40d8831f1UL,0xbd9c3b1d8UL,0x978364177UL,0x10f7606a9UL,0x46a64270aUL,0x42df1b22bUL,0xe906cf2a0UL,0x997da6fa5UL,0xa5722c26fUL,0xb14f58aaaUL,0xafc167ad8UL,0x37be56e60UL,0xde7f80d62UL,0xc3fb0a64UL,0xce8ca802cUL,0x35032ed9dUL,0xaa8ba3ee6UL,0x94b2e707cUL,0x2debbdae1UL,0xf53e25fcfUL,0xe935543ebUL,0x1462f0e90UL,0x54ce7d18cUL,0x2ddafdc5fUL,0x700565deeUL,0xfd408e0afUL,0x17d089decUL,0x833ea2459UL,0x3c8d3776aUL,0x2e5eebac8UL,0x20cbf49b0UL,0xc44675eb7UL,0x3a4b6beb1UL,0xce6f37c1eUL,0x63fba2e7cUL,0x5a05b553dUL,0x1286445b0UL,0x5e07a9b61UL,0x7d8397ea4UL,0x8084b7bbbUL,0xb05b38097UL,0x29c3019eeUL,0xed1d2708bUL,0x9df8a4d47UL,0xe4891e436UL,0x2a762ab72UL,0x92f70600fUL,0x92329a2cdUL,0x3e200c6edUL,0x8c0a7233eUL,0x60866806aUL,0xf4fddd24aUL,0xf78464c71UL,0x9c3d22242UL,0x3877ea6d1UL,0xe2a6d54acUL,0x497d2a5e7UL,0xca82f781eUL,0x481524f4cUL,0xdee088814UL,0xb2a82d3a4UL,0x8e6afe6e5UL,0xd6279a5daUL,0x4567cbc1aUL,0x5bec2b2fdUL,0x4ef452505UL,0x61d992cbaUL,0xab96be0cbUL,0x708ef35d9UL,0xb3f6f3623UL,0x36eb1801dUL,0xbadfee917UL,0xa3db13cd0UL,0x1d1a12828UL,0x2500816ceUL,0xcf7612148UL,0xbe6a3f4bUL,0x74142f3daUL,0xce5deed92UL,0xf9530a786UL,0x47c8bb38UL,0xfcabfe88fUL,0xbc83accb1UL,0x20cd9fb1fUL,0x23dcceb3UL,0x9e969b8c4UL,0x6e28de934UL,0x80a399667UL,0x76a0b85adUL,0x21a84be3cUL,0xa28d028b5UL,0xc4e7690dfUL,0xbfd9621e8UL,0x6f4bc0c24UL,0xaa8e76bd7UL,0xdeb55dac9UL,0xbb344fa8bUL,0xfcaab4decUL,0x146aba6cbUL,0xf49ed6eb8UL,0xdd57e9deaUL,0x225d5d090UL,0xd6e86c1c5UL,0x639be5f39UL,0xf5e7a6132UL,0xd2968b09fUL,0x82b30ba1eUL,0x803fa46ccUL,0xc290fab00UL,0x10df59de5UL,0x51ae9dcfbUL,0x49af8516dUL,0x2b564ce6UL,0xc615a1de0UL,0xfef9864a4UL,0xc16e27341UL,0x39e846736UL,0x1ecbb6746UL,0x588d03a7cUL,0x10a0eaf9cUL,0x671ccea6bUL,0x33a154603UL,0xa7b003bc1UL,0xc5fc3848dUL,0x78e50a9c7UL,0x17dbfb88eUL,0x4fd0ed541UL,0x84221debaUL,0x3132cf7e6UL,0xb67e7ac53UL,0xdf6b28024UL,0x785b9f7edUL,0xe3d35320dUL,0x159c06583UL,0x5c54a80a3UL,0xed4d4533bUL,0xcf16c601aUL,0x5e94efbd1UL,0x5d587126eUL,0xeef2f2807UL,0x9f3c558eUL,0x736cfd539UL,0xf5a922ae1UL,0x4e2ab9959UL,0x6a2dd34e7UL,0x8c9d30d23UL,0xeba20b791UL,0xd5c5095e3UL,0x423d75a82UL,0x40cebaafeUL,0x65e08d288UL,0x2e4f6d767UL,0xfe10d2f21UL,0x110347bdaUL,0xe43a9bfb3UL,0xcdea483ccUL,0xfb1e2d8c6UL,0xd8a0af7a7UL,0x37d05b182UL,0x8d1241d83UL,0xda1ea7b6eUL,0x65bea93dbUL,0x2a02f8753UL,0x454243289UL,0x4150bc5a2UL,0xbbabe5911UL,0x4cbcdbc59UL,0xf0e61340bUL,0x30a2cdea8UL,0x5daecb091UL,0x5dc93d891UL,0xc501b4051UL,0x782cfba78UL,0x4c191b61eUL,0xb7e27ef35UL,0x5a476838UL,0x9b0209574UL,0xa775164cfUL,0xd33d21701UL,0x3afcb7d45UL,0x4df2035cdUL,0x498819a21UL,0x293f9e506UL,0x9a35ff1c8UL,0xc090ebe6bUL,0xa4f0551d4UL,0x5dc0dc194UL,0x1388aeb31UL,0x340b27bf4UL,0x3a0f320abUL,0x996be75dUL,0xb257ecf39UL,0x78d86f2f1UL,0x673f5ff91UL,0x4538d7e3eUL,0xde5bc4369UL}; + fromVector(codes,d._code_id); + d._nbits=36; + d._tau=10; + d._type=TAG36h10; + d._name="TAG36h10"; + + }break; + case TAG16h5:{ + vector codes={0x231bUL,0x2ea5UL,0x346aUL,0x45b9UL,0x79a6UL,0x7f6bUL,0xb358UL,0xe745UL,0xfe59UL,0x156dUL,0x380bUL,0xf0abUL,0xd84UL,0x4736UL,0x8c72UL,0xaf10UL,0x93cUL,0x93b4UL,0xa503UL,0x468fUL,0xe137UL,0x5795UL,0xdf42UL,0x1c1dUL,0xe9dcUL,0x73adUL,0xad5fUL,0xd530UL,0x7caUL,0xaf2eUL}; + fromVector(codes,d._code_id); + d._nbits=16; + d._tau=5; + d._type=TAG16h5; + d._name="TAG16h5"; + + }break; + case TAG25h7:{ + vector codes={0x4b770dUL,0x11693e6UL,0x1a599abUL,0xc3a535UL,0x152aafaUL,0xaccd98UL,0x1cad922UL,0x2c2fadUL,0xbb3572UL,0x14a3b37UL,0x186524bUL,0xc99d4cUL,0x23bfeaUL,0x141cb74UL,0x1d0d139UL,0x1670aebUL,0x851675UL,0x150334eUL,0x6e3ed8UL,0xfd449dUL,0xaa55ecUL,0x1c86176UL,0x15e9b28UL,0x7ca6b2UL,0x147c38bUL,0x1d6c950UL,0x8b0e8cUL,0x11a1451UL,0x1562b65UL,0x13f53c8UL,0xd58d7aUL,0x829ec9UL,0xfaccf1UL,0x136e405UL,0x7a2f06UL,0x10934cbUL,0x16a8b56UL,0x1a6a26aUL,0xf85545UL,0x195c2e4UL,0x24c8a9UL,0x12bfc96UL,0x16813aaUL,0x1a42abeUL,0x1573424UL,0x1044573UL,0xb156c2UL,0x5e6811UL,0x1659bfeUL,0x1d55a63UL,0x5bf065UL,0xe28667UL,0x1e9ba54UL,0x17d7c5aUL,0x1f5aa82UL,0x1a2bbd1UL,0x1ae9f9UL,0x1259e51UL,0x134062bUL,0xe1177aUL,0xed07a8UL,0x162be24UL,0x59128bUL,0x1663e8fUL,0x1a83cbUL,0x45bb59UL,0x189065aUL,0x4bb370UL,0x16fb711UL,0x122c077UL,0xeca17aUL,0xdbc1f4UL,0x88d343UL,0x58ac5dUL,0xba02e8UL,0x1a1d9dUL,0x1c72eecUL,0x924bc5UL,0xdccab3UL,0x886d15UL,0x178c965UL,0x5bc69aUL,0x1716261UL,0x174e2ccUL,0x1ed10f4UL,0x156aa8UL,0x3e2a8aUL,0x2752edUL,0x153c651UL,0x1741670UL,0x765b05UL,0x119c0bbUL,0x172a783UL,0x4faca1UL,0xf31257UL,0x12441fcUL,0xd3748UL,0xc21f15UL,0xac5037UL,0x180e592UL,0x7d3210UL,0xa27187UL,0x2beeafUL,0x26ff57UL,0x690e82UL,0x77765cUL,0x1a9e1d7UL,0x140be1aUL,0x1aa1e3aUL,0x1944f5cUL,0x19b5032UL,0x169897UL,0x1068eb9UL,0xf30dbcUL,0x106a151UL,0x1d53e95UL,0x1348ceeUL,0xcf4fcaUL,0x1728bb5UL,0xdc1eecUL,0x69e8dbUL,0x16e1523UL,0x105fa25UL,0x18abb0cUL,0xc4275dUL,0x6d8e76UL,0xe8d6dbUL,0xe16fd7UL,0x1ac2682UL,0x77435bUL,0xa359ddUL,0x3a9c4eUL,0x123919aUL,0x1e25817UL,0x2a836UL,0x1545a4UL,0x1209c8dUL,0xbb5f69UL,0x1dc1f02UL,0x5d5f7eUL,0x12d0581UL,0x13786c2UL,0xe15409UL,0x1aa3599UL,0x139aad8UL,0xb09d2aUL,0x54488fUL,0x13c351cUL,0x976079UL,0xb25b12UL,0x1addb34UL,0x1cb23aeUL,0x1175738UL,0x1303bb8UL,0xd47716UL,0x188ceeaUL,0xbaf967UL,0x1226d39UL,0x135e99bUL,0x34adc5UL,0x2e384dUL,0x90d3faUL,0x232713UL,0x17d49b1UL,0xaa84d6UL,0xc2ddf8UL,0x1665646UL,0x4f345fUL,0x2276b1UL,0x1255dd7UL,0x16f4cccUL,0x4aaffcUL,0xc46da6UL,0x85c7b3UL,0x1311fcbUL,0x9c6c4fUL,0x187d947UL,0x8578e4UL,0xe2bf0bUL,0xa01b4cUL,0xa1493bUL,0x7ad766UL,0xccfe82UL,0x1981b5bUL,0x1cacc85UL,0x562cdbUL,0x15b0e78UL,0x8f66c5UL,0x3332bfUL,0x12ce754UL,0x96a76UL,0x1d5e3baUL,0x27ea41UL,0x14412dfUL,0x67b9b4UL,0xdaa51aUL,0x1dcb17UL,0x4d4afdUL,0x6335d5UL,0xee2334UL,0x17d4e55UL,0x1b8b0f0UL,0x14999e3UL,0x1513dfaUL,0x765cf2UL,0x56af90UL,0x12e16acUL,0x1d3d86cUL,0xff279bUL,0x18822ddUL,0x99d478UL,0x8dc0d2UL,0x34b666UL,0xcf9526UL,0x186443dUL,0x7a8e29UL,0x19c6aa5UL,0x1f2a27dUL,0x12b2136UL,0xd0cd0dUL,0x12cb320UL,0x17ddb0bUL,0x5353bUL,0x15b2cafUL,0x1e5a507UL,0x120f1e5UL,0x114605aUL,0x14efe4cUL,0x568134UL,0x11b9f92UL,0x174d2a7UL,0x692b1dUL,0x39e4feUL,0xaaff3dUL,0x96224cUL,0x13c9f77UL,0x110ee8fUL,0xf17beaUL,0x99fb5dUL,0x337141UL,0x2b54dUL,0x1233a70UL}; + fromVector(codes,d._code_id); + d._nbits=25; + d._tau=7; + d._type=TAG25h7; + d._name="TAG25h7"; + + }break; + case TAG25h9:{ + vector codes={0x155cbf1UL,0x1e4d1b6UL,0x17b0b68UL,0x1eac9cdUL,0x12e14ceUL,0x3548bbUL,0x7757e6UL,0x1065dabUL,0x1baa2e7UL,0xdea688UL,0x81d927UL,0x51b241UL,0xdbc8aeUL,0x1e50e19UL,0x15819d2UL,0x16d8282UL,0x163e035UL,0x9d9b81UL,0x173eec4UL,0xae3a09UL,0x5f7c51UL,0x1a137fcUL,0xdc9562UL,0x1802e45UL,0x1c3542cUL,0x870fa4UL,0x914709UL,0x16684f0UL,0xc8f2a5UL,0x833ebbUL,0x59717fUL,0x13cd050UL,0xfa0ad1UL,0x1b763b0UL,0xb991ceUL}; + fromVector(codes,d._code_id); + d._nbits=25; + d._tau=9; + d._type=TAG25h9; + d._name="TAG25h9"; + + }break; + case ARUCO_MIP_16h3:{ + + vector codes={0x5867UL,0x8b03UL,0x2537UL,0xb6c7UL,0xe45UL,0x161UL,0x219UL,0x859bUL,0x87UL,0xc93fUL,0x905fUL,0x3e73UL,0x6ab7UL,0x1bafUL,0x6f0fUL,0x23d3UL,0x47a5UL,0x8cf7UL,0x83cfUL,0x9205UL,0x29a5UL,0x8033UL,0x857dUL,0xa4afUL,0x422fUL,0x1d07UL,0x4ee3UL,0x64c5UL,0xaa7fUL,0x4b75UL,0x34dbUL,0x926UL,0x262UL,0x501dUL,0x415UL,0x6201UL,0x2064UL,0x2d5UL,0x10bUL,0x9427UL,0xc16bUL,0xa603UL,0x911UL,0x1043UL,0x87bUL,0xccfUL,0x162bUL,0x9ab3UL,0x30b7UL,0xad0bUL,0x60a6UL,0x3845UL,0xce2bUL,0xadc7UL,0x612UL,0x4253UL,0x9cc3UL,0xc23UL,0x409bUL,0x8e87UL,0x98e5UL,0x20f1UL,0xa807UL,0x1bfUL,0x7023UL,0xdf1UL,0x2957UL,0x26b3UL,0xd80fUL,0x4076UL,0x233bUL,0x32e3UL,0x7a85UL,0x4349UL,0xc857UL,0x41c6UL,0x3813UL,0x6d97UL,0x324fUL,0xe3fUL,0x47ffUL,0x2217UL,0xdd6fUL,0x48b1UL,0x8b95UL,0xd9c7UL,0x1a7dUL,0x867bUL,0xb7ffUL,0x7fa7UL,0x478bUL,0x6d43UL,0x6167UL,0x8f67UL,0xcda7UL,0x5cb7UL,0xf3afUL,0x889fUL,0x2fdfUL,0xd2e7UL,0x553UL,0xbc1fUL,0x7607UL,0x2a61UL,0x11ebUL,0xa457UL,0x789fUL,0x2e95UL,0xb46bUL,0x39ffUL,0x4fb6UL,0x647fUL,0x250dUL,0x5883UL,0xc5d7UL,0xe73fUL,0x129fUL,0x548fUL,0xb253UL,0x635fUL,0x1ed7UL,0xc647UL,0xa1f7UL,0x565fUL,0x7e6fUL,0xe10fUL,0xf56UL,0xf2dfUL,0x87a3UL,0x4b87UL,0x24f6UL,0xafb7UL,0x3bc7UL,0x51a7UL,0x6a47UL,0x4c46UL,0x6723UL,0x2787UL,0x2667UL,0x2f13UL,0x50d7UL,0x680dUL,0x7ad3UL,0x454fUL,0x6c35UL,0xf17fUL,0x6b91UL,0x4011UL,0x16UL,0x2022UL,0xa1UL,0x142UL,0x40fUL,0x1025UL,0xcbUL,0x45UL,0x4427UL,0x8491UL,0x2292UL,0x482bUL,0x8221UL,0x8293UL,0xf7UL,0x7dUL,0x601UL,0x84a5UL,0x2443UL,0x806fUL,0x21c1UL,0x4825UL,0x466UL,0x742dUL,0xca07UL,0x20bbUL,0x88a3UL,0x2251UL,0xa81UL,0x202dUL,0x205bUL,0x1a07UL,0x8119UL,0x6413UL,0x6105UL,0x820bUL,0x8715UL,0x1c0bUL,0xb003UL,0x307UL,0x147bUL,0x135UL,0x62a3UL,0x6c0bUL,0x14b3UL,0x5c05UL,0xd81UL,0x36dUL,0x8d3UL,0x8ba7UL,0xb25UL,0x4c5bUL,0x2867UL,0x242bUL,0x1237UL,0x4206UL,0xa0c3UL,0xa4f3UL,0x984bUL,0x8507UL,0x4529UL,0xf0dUL,0xb2bUL,0x2891UL,0x1a3bUL,0x234bUL,0x8d43UL,0x22e6UL,0x7245UL,0x1c77UL,0x825dUL,0x3487UL,0x60d6UL,0x5403UL,0x90e3UL,0xa43UL,0x6519UL,0x6169UL,0xc397UL,0x2285UL,0xc127UL,0x2c05UL,0x8871UL,0x5a0bUL,0x4e26UL,0x15afUL,0xf97UL,0x258bUL,0x463bUL,0x86c3UL,0x292fUL,0x9e3UL,0x2571UL,0x4ce5UL,0x81d5UL,0x459UL,0x40e2UL,0x5b6UL,0x4a33UL,0x837UL,0xa2a7UL,0xf4bUL};fromVector(codes,d._code_id); + d._nbits=16; + d._tau=3; + d._type=ARUCO_MIP_16h3; + d._name="ARUCO_MIP_16h3"; + + }break; + + case ARUCO_MIP_25h7:{ + vector codes={0x1ad2487UL,0x141b6e9UL,0x1780e66UL,0x1a86ad8UL,0x1146916UL,0x14ebcb6UL,0x1a1893cUL,0xd79525UL,0xf8db53UL,0x1b5928UL,0x127bf52UL,0x1cb3a02UL,0x145ed8cUL,0x3970efUL,0xc8934cUL,0x5badedUL,0x53c9daUL,0x1991f79UL,0x1d40a4dUL,0x1631993UL,0x74d97cUL,0x62c8a5UL,0x1a6ce96UL,0x1c71456UL,0x18d8df2UL,0xe290faUL,0x494061UL,0xedc6cdUL,0x12bd8f0UL,0x1a5d254UL,0x172eb3aUL,0x9d6e92UL,0x10a2172UL,0x1bd085aUL,0x186e528UL,0xb4af45UL,0x55a5b2UL,0x5e5136UL,0x88508bUL,0xea2c6fUL,0x1a9274cUL,0xbbb977UL,0x5ede62UL,0x105ba85UL,0x18a79bcUL,0x18d4b9dUL,0x1a144deUL,0x1ba5390UL,0x1b8a652UL,0x1c4948dUL,0x3ce285UL,0xb5cce7UL,0x16d2cb9UL,0xb7d338UL,0xb650e9UL,0x130e4b1UL,0xd3badcUL,0xf2161dUL,0x17a45a7UL,0x14c5c50UL,0x14be8abUL,0x1230de9UL,0xf7c242UL,0x508697UL,0x14b1cc5UL,0x2c1e94UL,0xf89469UL,0xdc52d8UL,0x6eb5c4UL,0xd8ea08UL,0x16c779dUL,0x1770dbeUL,0x90a4ecUL,0x1bf212eUL,0x1a4b99aUL,0x1d2d3a9UL,0xf4f5aeUL,0x842e89UL,0x1c0e8d4UL,0x1af4a4cUL,0x189044bUL,0xdd3108UL,0x1ab639eUL,0x18836c5UL,0x5f5ad3UL,0x1410f5dUL,0xeb532fUL,0xbda0baUL,0x9edf2dUL,0xd5ae4eUL,0x165d1b8UL,0x187d07aUL,0x1dd616dUL,0x912527UL,0x940c3cUL,0x516b8dUL,0xc1da19UL,0xc7db85UL,0x144cb34UL,0xcd7a34UL}; +fromVector(codes,d._code_id); + d._nbits=25; + d._tau=7; + d._type=ARUCO_MIP_25h7; + d._name="ARUCO_MIP_25h7"; + + + }break; + + case ARUCO_MIP_36h12:{ + vector codes={0xd2b63a09dUL,0x6001134e5UL,0x1206fbe72UL,0xff8ad6cb4UL,0x85da9bc49UL,0xb461afe9cUL,0x6db51fe13UL,0x5248c541fUL,0x8f34503UL,0x8ea462eceUL,0xeac2be76dUL,0x1af615c44UL,0xb48a49f27UL,0x2e4e1283bUL,0x78b1f2fa8UL,0x27d34f57eUL,0x89222fff1UL,0x4c1669406UL,0xbf49b3511UL,0xdc191cd5dUL,0x11d7c3f85UL,0x16a130e35UL,0xe29f27effUL,0x428d8ae0cUL,0x90d548477UL,0x2319cbc93UL,0xc3b0c3dfcUL,0x424bccc9UL,0x2a081d630UL,0x762743d96UL,0xd0645bf19UL,0xf38d7fd60UL,0xc6cbf9a10UL,0x3c1be7c65UL,0x276f75e63UL,0x4490a3f63UL,0xda60acd52UL,0x3cc68df59UL,0xab46f9daeUL,0x88d533d78UL,0xb6d62ec21UL,0xb3c02b646UL,0x22e56d408UL,0xac5f5770aUL,0xaaa993f66UL,0x4caa07c8dUL,0x5c9b4f7b0UL,0xaa9ef0e05UL,0x705c5750UL,0xac81f545eUL,0x735b91e74UL,0x8cc35cee4UL,0xe44694d04UL,0xb5e121de0UL,0x261017d0fUL,0xf1d439eb5UL,0xa1a33ac96UL,0x174c62c02UL,0x1ee27f716UL,0x8b1c5ece9UL,0x6a05b0c6aUL,0xd0568dfcUL,0x192d25e5fUL,0x1adbeccc8UL,0xcfec87f00UL,0xd0b9dde7aUL,0x88dcef81eUL,0x445681cb9UL,0xdbb2ffc83UL,0xa48d96df1UL,0xb72cc2e7dUL,0xc295b53fUL,0xf49832704UL,0x9968edc29UL,0x9e4e1af85UL,0x8683e2d1bUL,0x810b45c04UL,0x6ac44bfe2UL,0x645346615UL,0x3990bd598UL,0x1c9ed0f6aUL,0xc26729d65UL,0x83993f795UL,0x3ac05ac5dUL,0x357adff3bUL,0xd5c05565UL,0x2f547ef44UL,0x86c115041UL,0x640fd9e5fUL,0xce08bbcf7UL,0x109bb343eUL,0xc21435c92UL,0x35b4dfce4UL,0x459752cf2UL,0xec915b82cUL,0x51881eed0UL,0x2dda7dc97UL,0x2e0142144UL,0x42e890f99UL,0x9a8856527UL,0x8e80d9d80UL,0x891cbcf34UL,0x25dd82410UL,0x239551d34UL,0x8fe8f0c70UL,0x94106a970UL,0x82609b40cUL,0xfc9caf36UL,0x688181d11UL,0x718613c08UL,0xf1ab7629UL,0xa357bfc18UL,0x4c03b7a46UL,0x204dedce6UL,0xad6300d37UL,0x84cc4cd09UL,0x42160e5c4UL,0x87d2adfa8UL,0x7850e7749UL,0x4e750fc7cUL,0xbf2e5dfdaUL,0xd88324da5UL,0x234b52f80UL,0x378204514UL,0xabdf2ad53UL,0x365e78ef9UL,0x49caa6ca2UL,0x3c39ddf3UL,0xc68c5385dUL,0x5bfcbbf67UL,0x623241e21UL,0xabc90d5ccUL,0x388c6fe85UL,0xda0e2d62dUL,0x10855dfe9UL,0x4d46efd6bUL,0x76ea12d61UL,0x9db377d3dUL,0xeed0efa71UL,0xe6ec3ae2fUL,0x441faee83UL,0xba19c8ff5UL,0x313035eabUL,0x6ce8f7625UL,0x880dab58dUL,0x8d3409e0dUL,0x2be92ee21UL,0xd60302c6cUL,0x469ffc724UL,0x87eebeed3UL,0x42587ef7aUL,0x7a8cc4e52UL,0x76a437650UL,0x999e41ef4UL,0x7d0969e42UL,0xc02baf46bUL,0x9259f3e47UL,0x2116a1dc0UL,0x9f2de4d84UL,0xeffac29UL,0x7b371ff8cUL,0x668339da9UL,0xd010aee3fUL,0x1cd00b4c0UL,0x95070fc3bUL,0xf84c9a770UL,0x38f863d76UL,0x3646ff045UL,0xce1b96412UL,0x7a5d45da8UL,0x14e00ef6cUL,0x5e95abfd8UL,0xb2e9cb729UL,0x36c47dd7UL,0xb8ee97c6bUL,0xe9e8f657UL,0xd4ad2ef1aUL,0x8811c7f32UL,0x47bde7c31UL,0x3adadfb64UL,0x6e5b28574UL,0x33e67cd91UL,0x2ab9fdd2dUL,0x8afa67f2bUL,0xe6a28fc5eUL,0x72049cdbdUL,0xae65dac12UL,0x1251a4526UL,0x1089ab841UL,0xe2f096ee0UL,0xb0caee573UL,0xfd6677e86UL,0x444b3f518UL,0xbe8b3a56aUL,0x680a75cfcUL,0xac02baea8UL,0x97d815e1cUL,0x1d4386e08UL,0x1a14f5b0eUL,0xe658a8d81UL,0xa3868efa7UL,0x3668a9673UL,0xe8fc53d85UL,0x2e2b7edd5UL,0x8b2470f13UL,0xf69795f32UL,0x4589ffc8eUL,0x2e2080c9cUL,0x64265f7dUL,0x3d714dd10UL,0x1692c6ef1UL,0x3e67f2f49UL,0x5041dad63UL,0x1a1503415UL,0x64c18c742UL,0xa72eec35UL,0x1f0f9dc60UL,0xa9559bc67UL,0xf32911d0dUL,0x21c0d4ffcUL,0xe01cef5b0UL,0x4e23a3520UL,0xaa4f04e49UL,0xe1c4fcc43UL,0x208e8f6e8UL,0x8486774a5UL,0x9e98c7558UL,0x2c59fb7dcUL,0x9446a4613UL,0x8292dcc2eUL,0x4d61631UL,0xd05527809UL,0xa0163852dUL,0x8f657f639UL,0xcca6c3e37UL,0xcb136bc7aUL,0xfc5a83e53UL,0x9aa44fc30UL,0xbdec1bd3cUL,0xe020b9f7cUL,0x4b8f35fb0UL,0xb8165f637UL,0x33dc88d69UL,0x10a2f7e4dUL,0xc8cb5ff53UL,0xde259ff6bUL,0x46d070dd4UL,0x32d3b9741UL,0x7075f1c04UL,0x4d58dbea0UL}; + fromVector(codes,d._code_id); + d._nbits=36; + d._tau=12; + d._type=ARUCO_MIP_36h12; + d._name="ARUCO_MIP_36h12"; + + + }break; + case CHILITAGS:{ + vector codes={0x7c765c6e0c3e00UL,0x7c765c14121e00UL,0x7c765a06763e00UL,0x7c765a7c681e00UL,0x7c764248643e00UL,0x7c7642327a1e00UL,0x7c7644201e3e00UL,0x7c76445a001e00UL,0x7c7626702c3800UL,0x7c76260a321800UL,0x7c762018563800UL,0x7c762062481800UL,0x7c763856443800UL,0x7c76382c5a1800UL,0x7c763e3e3e3800UL,0x7c763e44201800UL,0x7c70346e120000UL,0x7c7034140c2000UL,0x7c703206680000UL,0x7c70327c762000UL,0x7c702a487a0000UL,0x7c702a32642000UL,0x7c702c20000000UL,0x7c702c5a1e2000UL,0x7c704e70320600UL,0x7c704e0a2c2600UL,0x7c704818480600UL,0x7c704862562600UL,0x7c7050565a0600UL,0x7c70502c442600UL,0x7c70563e200600UL,0x7c7056443e2600UL,0x7c687c6e764400UL,0x7c687c14686400UL,0x7c687a060c4400UL,0x7c687a7c126400UL,0x7c6862481e4400UL,0x7c686232006400UL,0x7c686420644400UL,0x7c68645a7a6400UL,0x7c680670564200UL,0x7c68060a486200UL,0x7c6800182c4200UL,0x7c680062326200UL,0x7c6818563e4200UL,0x7c68182c206200UL,0x7c681e3e444200UL,0x7c681e445a6200UL,0x7c6e146e687a00UL,0x7c6e1414765a00UL,0x7c6e1206127a00UL,0x7c6e127c0c5a00UL,0x7c6e0a48007a00UL,0x7c6e0a321e5a00UL,0x7c6e0c207a7a00UL,0x7c6e0c5a645a00UL,0x7c6e6e70487c00UL,0x7c6e6e0a565c00UL,0x7c6e6818327c00UL,0x7c6e68622c5c00UL,0x7c6e7056207c00UL,0x7c6e702c3e5c00UL,0x7c6e763e5a7c00UL,0x7c6e7644445c00UL,0x7c0c5c68625600UL,0x7c0c5c127c7600UL,0x7c0c5a00185600UL,0x7c0c5a7a067600UL,0x7c0c424e0a5600UL,0x7c0c4234147600UL,0x7c0c4426705600UL,0x7c0c445c6e7600UL,0x7c0c2676425000UL,0x7c0c260c5c7000UL,0x7c0c201e385000UL,0x7c0c2064267000UL,0x7c0c38502a5000UL,0x7c0c382a347000UL,0x7c0c3e38505000UL,0x7c0c3e424e7000UL,0x7c0a34687c6800UL,0x7c0a3412624800UL,0x7c0a3200066800UL,0x7c0a327a184800UL,0x7c0a2a4e146800UL,0x7c0a2a340a4800UL,0x7c0a2c266e6800UL,0x7c0a2c5c704800UL,0x7c0a4e765c6e00UL,0x7c0a4e0c424e00UL,0x7c0a481e266e00UL,0x7c0a4864384e00UL,0x7c0a5050346e00UL,0x7c0a502a2a4e00UL,0x7c0a56384e6e00UL,0x7c0a5642504e00UL,0x7c127c68182c00UL,0x7c127c12060c00UL,0x7c127a00622c00UL,0x7c127a7a7c0c00UL,0x7c12624e702c00UL,0x7c1262346e0c00UL,0x7c1264260a2c00UL,0x7c12645c140c00UL,0x7c120676382a00UL,0x7c12060c260a00UL,0x7c12001e422a00UL,0x7c1200645c0a00UL,0x7c121850502a00UL,0x7c12182a4e0a00UL,0x7c121e382a2a00UL,0x7c121e42340a00UL,0x7c141468061200UL,0x7c141412183200UL,0x7c1412007c1200UL,0x7c14127a623200UL,0x7c140a4e6e1200UL,0x7c140a34703200UL,0x7c140c26141200UL,0x7c140c5c0a3200UL,0x7c146e76261400UL,0x7c146e0c383400UL,0x7c14681e5c1400UL,0x7c146864423400UL,0x7c1470504e1400UL,0x7c14702a503400UL,0x7c147638341400UL,0x7c1476422a3400UL,0x7a1e5c70321800UL,0x7a1e5c0a2c3800UL,0x7a1e5a18481800UL,0x7a1e5a62563800UL,0x7a1e42565a1800UL,0x7a1e422c443800UL,0x7a1e443e201800UL,0x7a1e44443e3800UL,0x7a1e266e121e00UL,0x7a1e26140c3e00UL,0x7a1e2006681e00UL,0x7a1e207c763e00UL,0x7a1e38487a1e00UL,0x7a1e3832643e00UL,0x7a1e3e20001e00UL,0x7a1e3e5a1e3e00UL,0x7a1834702c2600UL,0x7a18340a320600UL,0x7a183218562600UL,0x7a183262480600UL,0x7a182a56442600UL,0x7a182a2c5a0600UL,0x7a182c3e3e2600UL,0x7a182c44200600UL,0x7a184e6e0c2000UL,0x7a184e14120000UL,0x7a184806762000UL,0x7a18487c680000UL,0x7a185048642000UL,0x7a1850327a0000UL,0x7a1856201e2000UL,0x7a18565a000000UL,0x7a007c70486200UL,0x7a007c0a564200UL,0x7a007a18326200UL,0x7a007a622c4200UL,0x7a006256206200UL,0x7a00622c3e4200UL,0x7a00643e5a6200UL,0x7a006444444200UL,0x7a00066e686400UL,0x7a000614764400UL,0x7a000006126400UL,0x7a00007c0c4400UL,0x7a001848006400UL,0x7a0018321e4400UL,0x7a001e207a6400UL,0x7a001e5a644400UL,0x7a061470565c00UL,0x7a06140a487c00UL,0x7a0612182c5c00UL,0x7a061262327c00UL,0x7a060a563e5c00UL,0x7a060a2c207c00UL,0x7a060c3e445c00UL,0x7a060c445a7c00UL,0x7a066e6e765a00UL,0x7a066e14687a00UL,0x7a0668060c5a00UL,0x7a06687c127a00UL,0x7a0670481e5a00UL,0x7a067032007a00UL,0x7a067620645a00UL,0x7a06765a7a7a00UL,0x7a645c765c7000UL,0x7a645c0c425000UL,0x7a645a1e267000UL,0x7a645a64385000UL,0x7a644250347000UL,0x7a64422a2a5000UL,0x7a6444384e7000UL,0x7a644442505000UL,0x7a6426687c7600UL,0x7a642612625600UL,0x7a642000067600UL,0x7a64207a185600UL,0x7a64384e147600UL,0x7a6438340a5600UL,0x7a643e266e7600UL,0x7a643e5c705600UL,0x7a623476424e00UL,0x7a62340c5c6e00UL,0x7a62321e384e00UL,0x7a623264266e00UL,0x7a622a502a4e00UL,0x7a622a2a346e00UL,0x7a622c38504e00UL,0x7a622c424e6e00UL,0x7a624e68624800UL,0x7a624e127c6800UL,0x7a624800184800UL,0x7a62487a066800UL,0x7a62504e0a4800UL,0x7a625034146800UL,0x7a625626704800UL,0x7a62565c6e6800UL,0x7a7a7c76260a00UL,0x7a7a7c0c382a00UL,0x7a7a7a1e5c0a00UL,0x7a7a7a64422a00UL,0x7a7a62504e0a00UL,0x7a7a622a502a00UL,0x7a7a6438340a00UL,0x7a7a64422a2a00UL,0x7a7a0668060c00UL,0x7a7a0612182c00UL,0x7a7a00007c0c00UL,0x7a7a007a622c00UL,0x7a7a184e6e0c00UL,0x7a7a1834702c00UL,0x7a7a1e26140c00UL,0x7a7a1e5c0a2c00UL,0x7a7c1476383400UL,0x7a7c140c261400UL,0x7a7c121e423400UL,0x7a7c12645c1400UL,0x7a7c0a50503400UL,0x7a7c0a2a4e1400UL,0x7a7c0c382a3400UL,0x7a7c0c42341400UL,0x7a7c6e68183200UL,0x7a7c6e12061200UL,0x7a7c6800623200UL,0x7a7c687a7c1200UL,0x7a7c704e703200UL,0x7a7c70346e1200UL,0x7a7c76260a3200UL,0x7a7c765c141200UL,0x62565c6e680600UL,0x62565c14762600UL,0x62565a06120600UL,0x62565a7c0c2600UL,0x62564248000600UL,0x625642321e2600UL,0x625644207a0600UL,0x6256445a642600UL,0x62562670480000UL,0x6256260a562000UL,0x62562018320000UL,0x625620622c2000UL,0x62563856200000UL,0x6256382c3e2000UL,0x62563e3e5a0000UL,0x62563e44442000UL,0x6250346e763800UL,0x62503414681800UL,0x625032060c3800UL,0x6250327c121800UL,0x62502a481e3800UL,0x62502a32001800UL,0x62502c20643800UL,0x62502c5a7a1800UL,0x62504e70563e00UL,0x62504e0a481e00UL,0x625048182c3e00UL,0x62504862321e00UL,0x625050563e3e00UL,0x6250502c201e00UL,0x6250563e443e00UL,0x625056445a1e00UL,0x62487c6e127c00UL,0x62487c140c5c00UL,0x62487a06687c00UL,0x62487a7c765c00UL,0x624862487a7c00UL,0x62486232645c00UL,0x62486420007c00UL,0x6248645a1e5c00UL,0x62480670327a00UL,0x6248060a2c5a00UL,0x62480018487a00UL,0x62480062565a00UL,0x624818565a7a00UL,0x6248182c445a00UL,0x62481e3e207a00UL,0x62481e443e5a00UL,0x624e146e0c4200UL,0x624e1414126200UL,0x624e1206764200UL,0x624e127c686200UL,0x624e0a48644200UL,0x624e0a327a6200UL,0x624e0c201e4200UL,0x624e0c5a006200UL,0x624e6e702c4400UL,0x624e6e0a326400UL,0x624e6818564400UL,0x624e6862486400UL,0x624e7056444400UL,0x624e702c5a6400UL,0x624e763e3e4400UL,0x624e7644206400UL,0x622c5c68066e00UL,0x622c5c12184e00UL,0x622c5a007c6e00UL,0x622c5a7a624e00UL,0x622c424e6e6e00UL,0x622c4234704e00UL,0x622c4426146e00UL,0x622c445c0a4e00UL,0x622c2676266800UL,0x622c260c384800UL,0x622c201e5c6800UL,0x622c2064424800UL,0x622c38504e6800UL,0x622c382a504800UL,0x622c3e38346800UL,0x622c3e422a4800UL,0x622a3468185000UL,0x622a3412067000UL,0x622a3200625000UL,0x622a327a7c7000UL,0x622a2a4e705000UL,0x622a2a346e7000UL,0x622a2c260a5000UL,0x622a2c5c147000UL,0x622a4e76385600UL,0x622a4e0c267600UL,0x622a481e425600UL,0x622a48645c7600UL,0x622a5050505600UL,0x622a502a4e7600UL,0x622a56382a5600UL,0x622a5642347600UL,0x62327c687c1400UL,0x62327c12623400UL,0x62327a00061400UL,0x62327a7a183400UL,0x6232624e141400UL,0x623262340a3400UL,0x623264266e1400UL,0x6232645c703400UL,0x623206765c1200UL,0x6232060c423200UL,0x6232001e261200UL,0x62320064383200UL,0x62321850341200UL,0x6232182a2a3200UL,0x62321e384e1200UL,0x62321e42503200UL,0x62341468622a00UL,0x623414127c0a00UL,0x62341200182a00UL,0x6234127a060a00UL,0x62340a4e0a2a00UL,0x62340a34140a00UL,0x62340c26702a00UL,0x62340c5c6e0a00UL,0x62346e76422c00UL,0x62346e0c5c0c00UL,0x6234681e382c00UL,0x62346864260c00UL,0x623470502a2c00UL,0x6234702a340c00UL,0x62347638502c00UL,0x623476424e0c00UL,0x643e5c70562000UL,0x643e5c0a480000UL,0x643e5a182c2000UL,0x643e5a62320000UL,0x643e42563e2000UL,0x643e422c200000UL,0x643e443e442000UL,0x643e44445a0000UL,0x643e266e762600UL,0x643e2614680600UL,0x643e20060c2600UL,0x643e207c120600UL,0x643e38481e2600UL,0x643e3832000600UL,0x643e3e20642600UL,0x643e3e5a7a0600UL,0x64383470481e00UL,0x6438340a563e00UL,0x64383218321e00UL,0x643832622c3e00UL,0x64382a56201e00UL,0x64382a2c3e3e00UL,0x64382c3e5a1e00UL,0x64382c44443e00UL,0x64384e6e681800UL,0x64384e14763800UL,0x64384806121800UL,0x6438487c0c3800UL,0x64385048001800UL,0x643850321e3800UL,0x643856207a1800UL,0x6438565a643800UL,0x64207c702c5a00UL,0x64207c0a327a00UL,0x64207a18565a00UL,0x64207a62487a00UL,0x64206256445a00UL,0x6420622c5a7a00UL,0x6420643e3e5a00UL,0x64206444207a00UL,0x6420066e0c5c00UL,0x64200614127c00UL,0x64200006765c00UL,0x6420007c687c00UL,0x64201848645c00UL,0x642018327a7c00UL,0x64201e201e5c00UL,0x64201e5a007c00UL,0x64261470326400UL,0x6426140a2c4400UL,0x64261218486400UL,0x64261262564400UL,0x64260a565a6400UL,0x64260a2c444400UL,0x64260c3e206400UL,0x64260c443e4400UL,0x64266e6e126200UL,0x64266e140c4200UL,0x64266806686200UL,0x6426687c764200UL,0x642670487a6200UL,0x64267032644200UL,0x64267620006200UL,0x6426765a1e4200UL,0x64445c76384800UL,0x64445c0c266800UL,0x64445a1e424800UL,0x64445a645c6800UL,0x64444250504800UL,0x6444422a4e6800UL,0x644444382a4800UL,0x64444442346800UL,0x64442668184e00UL,0x64442612066e00UL,0x64442000624e00UL,0x6444207a7c6e00UL,0x6444384e704e00UL,0x644438346e6e00UL,0x64443e260a4e00UL,0x64443e5c146e00UL,0x64423476267600UL,0x6442340c385600UL,0x6442321e5c7600UL,0x64423264425600UL,0x64422a504e7600UL,0x64422a2a505600UL,0x64422c38347600UL,0x64422c422a5600UL,0x64424e68067000UL,0x64424e12185000UL,0x644248007c7000UL,0x6442487a625000UL,0x6442504e6e7000UL,0x64425034705000UL,0x64425626147000UL,0x6442565c0a5000UL,0x645a7c76423200UL,0x645a7c0c5c1200UL,0x645a7a1e383200UL,0x645a7a64261200UL,0x645a62502a3200UL,0x645a622a341200UL,0x645a6438503200UL,0x645a64424e1200UL,0x645a0668623400UL,0x645a06127c1400UL,0x645a0000183400UL,0x645a007a061400UL,0x645a184e0a3400UL,0x645a1834141400UL,0x645a1e26703400UL,0x645a1e5c6e1400UL,0x645c14765c0c00UL,0x645c140c422c00UL,0x645c121e260c00UL,0x645c1264382c00UL,0x645c0a50340c00UL,0x645c0a2a2a2c00UL,0x645c0c384e0c00UL,0x645c0c42502c00UL,0x645c6e687c0a00UL,0x645c6e12622a00UL,0x645c6800060a00UL,0x645c687a182a00UL,0x645c704e140a00UL,0x645c70340a2a00UL,0x645c76266e0a00UL,0x645c765c702a00UL,0x6765c681e5a00UL,0x6765c12007a00UL,0x6765a00645a00UL,0x6765a7a7a7a00UL,0x676424e765a00UL,0x6764234687a00UL,0x67644260c5a00UL,0x676445c127a00UL,0x67626763e5c00UL,0x676260c207c00UL,0x676201e445c00UL,0x67620645a7c00UL,0x6763850565c00UL,0x676382a487c00UL,0x6763e382c5c00UL,0x6763e42327c00UL,0x6703468006400UL,0x67034121e4400UL,0x67032007a6400UL,0x670327a644400UL,0x6702a4e686400UL,0x6702a34764400UL,0x6702c26126400UL,0x6702c5c0c4400UL,0x6704e76206200UL,0x6704e0c3e4200UL,0x670481e5a6200UL,0x6704864444200UL,0x6705050486200UL,0x670502a564200UL,0x6705638326200UL,0x67056422c4200UL,0x6687c68642000UL,0x6687c127a0000UL,0x6687a001e2000UL,0x6687a7a000000UL,0x668624e0c2000UL,0x6686234120000UL,0x6686426762000UL,0x668645c680000UL,0x6680676442600UL,0x668060c5a0600UL,0x668001e3e2600UL,0x6680064200600UL,0x66818502c2600UL,0x668182a320600UL,0x6681e38562600UL,0x6681e42480600UL,0x66e14687a1e00UL,0x66e1412643e00UL,0x66e1200001e00UL,0x66e127a1e3e00UL,0x66e0a4e121e00UL,0x66e0a340c3e00UL,0x66e0c26681e00UL,0x66e0c5c763e00UL,0x66e6e765a1800UL,0x66e6e0c443800UL,0x66e681e201800UL,0x66e68643e3800UL,0x66e7050321800UL,0x66e702a2c3800UL,0x66e7638481800UL,0x66e7642563800UL,0x60c5c6e703200UL,0x60c5c146e1200UL,0x60c5a060a3200UL,0x60c5a7c141200UL,0x60c4248183200UL,0x60c4232061200UL,0x60c4420623200UL,0x60c445a7c1200UL,0x60c2670503400UL,0x60c260a4e1400UL,0x60c20182a3400UL,0x60c2062341400UL,0x60c3856383400UL,0x60c382c261400UL,0x60c3e3e423400UL,0x60c3e445c1400UL,0x60a346e6e0c00UL,0x60a3414702c00UL,0x60a3206140c00UL,0x60a327c0a2c00UL,0x60a2a48060c00UL,0x60a2a32182c00UL,0x60a2c207c0c00UL,0x60a2c5a622c00UL,0x60a4e704e0a00UL,0x60a4e0a502a00UL,0x60a4818340a00UL,0x60a48622a2a00UL,0x60a5056260a00UL,0x60a502c382a00UL,0x60a563e5c0a00UL,0x60a5644422a00UL,0x6127c6e0a4800UL,0x6127c14146800UL,0x6127a06704800UL,0x6127a7c6e6800UL,0x6126248624800UL,0x61262327c6800UL,0x6126420184800UL,0x612645a066800UL,0x61206702a4e00UL,0x612060a346e00UL,0x6120018504e00UL,0x61200624e6e00UL,0x6121856424e00UL,0x612182c5c6e00UL,0x6121e3e384e00UL,0x6121e44266e00UL,0x614146e147600UL,0x61414140a5600UL,0x61412066e7600UL,0x614127c705600UL,0x6140a487c7600UL,0x6140a32625600UL,0x6140c20067600UL,0x6140c5a185600UL,0x6146e70347000UL,0x6146e0a2a5000UL,0x61468184e7000UL,0x6146862505000UL,0x61470565c7000UL,0x614702c425000UL,0x614763e267000UL,0x6147644385000UL,0x1e5c76207c00UL,0x1e5c0c3e5c00UL,0x1e5a1e5a7c00UL,0x1e5a64445c00UL,0x1e4250487c00UL,0x1e422a565c00UL,0x1e4438327c00UL,0x1e44422c5c00UL,0x1e2668007a00UL,0x1e26121e5a00UL,0x1e20007a7a00UL,0x1e207a645a00UL,0x1e384e687a00UL,0x1e3834765a00UL,0x1e3e26127a00UL,0x1e3e5c0c5a00UL,0x1834763e4200UL,0x18340c206200UL,0x18321e444200UL,0x1832645a6200UL,0x182a50564200UL,0x182a2a486200UL,0x182c382c4200UL,0x182c42326200UL,0x184e681e4400UL,0x184e12006400UL,0x184800644400UL,0x18487a7a6400UL,0x18504e764400UL,0x185034686400UL,0x1856260c4400UL,0x18565c126400UL,0x7c765a0600UL,0x7c0c442600UL,0x7a1e200600UL,0x7a643e2600UL,0x6250320600UL,0x622a2c2600UL,0x6438480600UL,0x6442562600UL,0x6687a0000UL,0x612642000UL,0x0UL,0x7a1e2000UL,0x184e120000UL,0x18340c2000UL,0x1e26680000UL,0x1e5c762000UL,0x61476443800UL,0x6140c5a1800UL,0x6121e3e3800UL,0x61264201800UL,0x60a502c3800UL,0x60a2a321800UL,0x60c38563800UL,0x60c42481800UL,0x66e68643e00UL,0x66e127a1e00UL,0x668001e3e00UL,0x6687a001e00UL,0x6704e0c3e00UL,0x67034121e00UL,0x67626763e00UL,0x6765c681e00UL,0x645c704e1400UL,0x645c0a503400UL,0x645a18341400UL,0x645a622a3400UL,0x644256261400UL,0x64422c383400UL,0x64443e5c1400UL,0x644444423400UL,0x64266e6e1200UL,0x642614703200UL,0x642006141200UL,0x64207c0a3200UL,0x643848061200UL,0x643832183200UL,0x643e207c1200UL,0x643e5a623200UL,0x623470502a00UL,0x62340a4e0a00UL,0x6232182a2a00UL,0x623262340a00UL,0x622a56382a00UL,0x622a2c260a00UL,0x622c3e422a00UL,0x622c445c0a00UL,0x624e6e702c00UL,0x624e146e0c00UL,0x6248060a2c00UL,0x62487c140c00UL,0x625048182c00UL,0x625032060c00UL,0x625620622c00UL,0x62565a7c0c00UL,0x7a7c70346e00UL,0x7a7c0a2a4e00UL,0x7a7a184e6e00UL,0x7a7a62504e00UL,0x7a62565c6e00UL,0x7a622c424e00UL,0x7a643e266e00UL,0x7a6444384e00UL,0x7a066e146800UL,0x7a06140a4800UL,0x7a00066e6800UL,0x7a007c704800UL,0x7a18487c6800UL,0x7a1832624800UL,0x7a1e20066800UL,0x7a1e5a184800UL,0x7c14702a5000UL,0x7c140a347000UL,0x7c1218505000UL,0x7c12624e7000UL,0x7c0a56425000UL,0x7c0a2c5c7000UL,0x7c0c3e385000UL,0x7c0c44267000UL,0x7c6e6e0a5600UL,0x7c6e14147600UL,0x7c6806705600UL,0x7c687c6e7600UL,0x7c7048625600UL,0x7c70327c7600UL,0x7c7620185600UL,0x7c765a067600UL,0x18565c687a6200UL,0x18565c12644200UL,0x18565a00006200UL,0x18565a7a1e4200UL,0x1856424e126200UL,0x185642340c4200UL,0x18564426686200UL,0x1856445c764200UL,0x185626765a6400UL,0x1856260c444400UL,0x1856201e206400UL,0x185620643e4400UL,0x18563850326400UL,0x1856382a2c4400UL,0x18563e38486400UL,0x18563e42564400UL,0x18503468645c00UL,0x185034127a7c00UL,0x185032001e5c00UL,0x1850327a007c00UL,0x18502a4e0c5c00UL,0x18502a34127c00UL,0x18502c26765c00UL,0x18502c5c687c00UL,0x18504e76445a00UL,0x18504e0c5a7a00UL,0x1850481e3e5a00UL,0x18504864207a00UL,0x185050502c5a00UL,0x1850502a327a00UL,0x18505638565a00UL,0x18505642487a00UL,0x18487c68001800UL,0x18487c121e3800UL,0x18487a007a1800UL,0x18487a7a643800UL,0x1848624e681800UL,0x18486234763800UL,0x18486426121800UL,0x1848645c0c3800UL,0x18480676201e00UL,0x1848060c3e3e00UL,0x1848001e5a1e00UL,0x18480064443e00UL,0x18481850481e00UL,0x1848182a563e00UL,0x18481e38321e00UL,0x18481e422c3e00UL,0x184e14681e2600UL,0x184e1412000600UL,0x184e1200642600UL,0x184e127a7a0600UL,0x184e0a4e762600UL,0x184e0a34680600UL,0x184e0c260c2600UL,0x184e0c5c120600UL,0x184e6e763e2000UL,0x184e6e0c200000UL,0x184e681e442000UL,0x184e68645a0000UL,0x184e7050562000UL,0x184e702a480000UL,0x184e76382c2000UL,0x184e7642320000UL,0x182c5c6e140a00UL,0x182c5c140a2a00UL,0x182c5a066e0a00UL,0x182c5a7c702a00UL,0x182c42487c0a00UL,0x182c4232622a00UL,0x182c4420060a00UL,0x182c445a182a00UL,0x182c2670340c00UL,0x182c260a2a2c00UL,0x182c20184e0c00UL,0x182c2062502c00UL,0x182c38565c0c00UL,0x182c382c422c00UL,0x182c3e3e260c00UL,0x182c3e44382c00UL,0x182a346e0a3400UL,0x182a3414141400UL,0x182a3206703400UL,0x182a327c6e1400UL,0x182a2a48623400UL,0x182a2a327c1400UL,0x182a2c20183400UL,0x182a2c5a061400UL,0x182a4e702a3200UL,0x182a4e0a341200UL,0x182a4818503200UL,0x182a48624e1200UL,0x182a5056423200UL,0x182a502c5c1200UL,0x182a563e383200UL,0x182a5644261200UL,0x18327c6e6e7000UL,0x18327c14705000UL,0x18327a06147000UL,0x18327a7c0a5000UL,0x18326248067000UL,0x18326232185000UL,0x183264207c7000UL,0x1832645a625000UL,0x183206704e7600UL,0x1832060a505600UL,0x18320018347600UL,0x183200622a5600UL,0x18321856267600UL,0x1832182c385600UL,0x18321e3e5c7600UL,0x18321e44425600UL,0x1834146e704e00UL,0x183414146e6e00UL,0x183412060a4e00UL,0x1834127c146e00UL,0x18340a48184e00UL,0x18340a32066e00UL,0x18340c20624e00UL,0x18340c5a7c6e00UL,0x18346e70504800UL,0x18346e0a4e6800UL,0x183468182a4800UL,0x18346862346800UL,0x18347056384800UL,0x1834702c266800UL,0x1834763e424800UL,0x183476445c6800UL,0x1e3e5c76444400UL,0x1e3e5c0c5a6400UL,0x1e3e5a1e3e4400UL,0x1e3e5a64206400UL,0x1e3e42502c4400UL,0x1e3e422a326400UL,0x1e3e4438564400UL,0x1e3e4442486400UL,0x1e3e2668644200UL,0x1e3e26127a6200UL,0x1e3e20001e4200UL,0x1e3e207a006200UL,0x1e3e384e0c4200UL,0x1e3e3834126200UL,0x1e3e3e26764200UL,0x1e3e3e5c686200UL,0x1e3834765a7a00UL,0x1e38340c445a00UL,0x1e38321e207a00UL,0x1e3832643e5a00UL,0x1e382a50327a00UL,0x1e382a2a2c5a00UL,0x1e382c38487a00UL,0x1e382c42565a00UL,0x1e384e687a7c00UL,0x1e384e12645c00UL,0x1e384800007c00UL,0x1e38487a1e5c00UL,0x1e38504e127c00UL,0x1e3850340c5c00UL,0x1e385626687c00UL,0x1e38565c765c00UL,0x1e207c763e3e00UL,0x1e207c0c201e00UL,0x1e207a1e443e00UL,0x1e207a645a1e00UL,0x1e206250563e00UL,0x1e20622a481e00UL,0x1e2064382c3e00UL,0x1e206442321e00UL,0x1e2006681e3800UL,0x1e200612001800UL,0x1e200000643800UL,0x1e20007a7a1800UL,0x1e20184e763800UL,0x1e201834681800UL,0x1e201e260c3800UL,0x1e201e5c121800UL,0x1e261476200000UL,0x1e26140c3e2000UL,0x1e26121e5a0000UL,0x1e261264442000UL,0x1e260a50480000UL,0x1e260a2a562000UL,0x1e260c38320000UL,0x1e260c422c2000UL,0x1e266e68000600UL,0x1e266e121e2600UL,0x1e2668007a0600UL,0x1e26687a642600UL,0x1e26704e680600UL,0x1e267034762600UL,0x1e267626120600UL,0x1e26765c0c2600UL,0x1e445c702a2c00UL,0x1e445c0a340c00UL,0x1e445a18502c00UL,0x1e445a624e0c00UL,0x1e444256422c00UL,0x1e44422c5c0c00UL,0x1e44443e382c00UL,0x1e444444260c00UL,0x1e44266e0a2a00UL,0x1e442614140a00UL,0x1e442006702a00UL,0x1e44207c6e0a00UL,0x1e443848622a00UL,0x1e4438327c0a00UL,0x1e443e20182a00UL,0x1e443e5a060a00UL,0x1e423470341200UL,0x1e42340a2a3200UL,0x1e4232184e1200UL,0x1e423262503200UL,0x1e422a565c1200UL,0x1e422a2c423200UL,0x1e422c3e261200UL,0x1e422c44383200UL,0x1e424e6e141400UL,0x1e424e140a3400UL,0x1e4248066e1400UL,0x1e42487c703400UL,0x1e4250487c1400UL,0x1e425032623400UL,0x1e425620061400UL,0x1e42565a183400UL,0x1e5a7c70505600UL,0x1e5a7c0a4e7600UL,0x1e5a7a182a5600UL,0x1e5a7a62347600UL,0x1e5a6256385600UL,0x1e5a622c267600UL,0x1e5a643e425600UL,0x1e5a64445c7600UL,0x1e5a066e705000UL,0x1e5a06146e7000UL,0x1e5a00060a5000UL,0x1e5a007c147000UL,0x1e5a1848185000UL,0x1e5a1832067000UL,0x1e5a1e20625000UL,0x1e5a1e5a7c7000UL,0x1e5c14704e6800UL,0x1e5c140a504800UL,0x1e5c1218346800UL,0x1e5c12622a4800UL,0x1e5c0a56266800UL,0x1e5c0a2c384800UL,0x1e5c0c3e5c6800UL,0x1e5c0c44424800UL,0x1e5c6e6e6e6e00UL,0x1e5c6e14704e00UL,0x1e5c6806146e00UL,0x1e5c687c0a4e00UL,0x1e5c7048066e00UL,0x1e5c7032184e00UL,0x1e5c76207c6e00UL,0x1e5c765a624e00UL}; + fromVector(codes,d._code_id); + d._nbits=64; + d._tau=5; + d._type=CHILITAGS; + d._name="CHILITAGS"; + + }break; + case CUSTOM: + throw cv::Exception(-1,"CUSTOM type is only set by loading from file","Dictionary::loadPredefined","dictionary.h",-1); + break; + case ALL_DICTS:{ + d._nbits=64; + d._tau=1;// + d._type=ALL_DICTS; + d._name="ALL_DICTS"; + }break; + + default: throw cv::Exception(9001, "Invalid Dictionary type requested", "Dictionary::loadPredefined", __FILE__, __LINE__); + + }; + return d; +} +/** + * @brief Dictionary::getMarkerImage_id + * @param id + * @return + */ +cv::Mat Dictionary::getMarkerImage_id(int id,int bit_size,bool addWaterMark,bool enclosed_corners,bool externalWhiteBorder,bool centralCircle) +{ + const int nBitsSquared = static_cast(std::sqrt(nbits())); + const int A=bit_size*(2+nBitsSquared); + + cv::Mat img=cv::Mat::zeros(A,A,CV_8UC1); + + //find the code in the map + uint64_t code; + bool found=false; + for(auto c_id:_code_id) + if(c_id.second==id){ + found=true; + code=c_id.first; + break; + } + if (!found) { + cerr<<"marker "< bset=code; + + int bidx=0; + for (int y = nBitsSquared-1; y >=0 ; y--) + for (int x = nBitsSquared-1; x >=0; x--){ + if (bset[bidx++]){ + cv::Mat bit_pix=img( cv::Range((1+y)*bit_size,(2+y)*bit_size),cv::Range((1+x)*bit_size,(2+x)*bit_size)); + bit_pix.setTo(cv::Scalar::all(255)); + } + } + + if (addWaterMark){ + char idcad[30]; + sprintf(idcad, "#%d", id); + float ax = static_cast(A) / 100.f; + int linew = 1 + (img.rows / 500); + cv::putText(img, idcad, cv::Point(0, img.rows - img.rows / 40), cv::FONT_HERSHEY_COMPLEX, ax * 0.15f, cv::Scalar::all(30), linew); + + } + + + if (enclosed_corners){ + cv::Mat biggerImage( img.rows+img.rows/2,img.cols+img.cols/2,img.type()); + biggerImage.setTo(cv::Scalar::all(255)); + //set the image in the center + int sy=img.rows/4; + int sx=img.cols/4; + cv::Mat center=biggerImage(cv::Range(sy,sy+img.rows),cv::Range(sx,sx+img.cols)); + img.copyTo(center); + biggerImage(cv::Range(0,sy),cv::Range(0,sx)).setTo(cv::Scalar::all(0)); + biggerImage(cv::Range(biggerImage.rows-sy,biggerImage.rows),cv::Range(0,sx)).setTo(cv::Scalar::all(0)); + biggerImage(cv::Range(biggerImage.rows-sy,biggerImage.rows),cv::Range(biggerImage.cols- sx,biggerImage.cols)).setTo(cv::Scalar::all(0)); + biggerImage(cv::Range(0,sy),cv::Range(biggerImage.cols- sx,biggerImage.cols)).setTo(cv::Scalar::all(0)); + + img=biggerImage; + } + + if (externalWhiteBorder && !enclosed_corners){ + int borderSize=bit_size; + //Create another image in white and put the marker in the middle + cv::Mat biggerImage( img.rows+2*borderSize,img.cols+2*borderSize,img.type()); + biggerImage.setTo(cv::Scalar::all(255)); + //set the image in the center + cv::Mat center=biggerImage(cv::Range(borderSize,borderSize+img.rows),cv::Range(borderSize,borderSize+img.cols)); + img.copyTo(center); + img=biggerImage; + } + + if( centralCircle ){ + + //at the image center, draw a circle to mark the center + cv::Point2f center(img.cols/2,img.rows/2); + cv::Mat mask(img.size(),CV_8UC1); + mask.setTo(cv::Scalar::all(0)); + cv::circle(mask,center,sqrt(bit_size),cv::Scalar::all(255),-1); + //now, invert the color in the image + for(int r=0;r(r); + uchar *maskptr=mask.ptr(r); + for(int c=0;c to convert to Dictionary type", "Dictionary::getTypeFromString", __FILE__, __LINE__); + + } + +bool Dictionary::isPredefinedDictinaryString(string str) { + return getTypeFromString(str)!=CUSTOM; +} + +vector Dictionary::getDicTypes() { +return { "ARUCO","ARUCO_MIP_16h3","ARUCO_MIP_25h7","ARUCO_MIP_36h12", "ARTOOLKITPLUS","ARTOOLKITPLUSBCH","TAG16h5","TAG25h7","TAG25h9" + ,"TAG36h11","TAG36h10","CHILITAGS","ALL_DICTS"}; + +} + +MarkerMap Dictionary::createMarkerMap( cv::Size gridSize,int MarkerSize,int MarkerDistance, const std::vector &ids,bool chess_board) { + if (gridSize.height*gridSize.width!=int(ids.size()))throw cv::Exception(9001, "gridSize != ids.size()Invalid ", "Dictionary::createMarkerMap", __FILE__, __LINE__); + MarkerMap TInfo; + + TInfo.mInfoType=MarkerMap::PIX; + TInfo.setDictionary(getTypeString(_type)); + const float markerSizeFloat = static_cast(MarkerSize); + + + if (!chess_board){ + TInfo.resize(ids.size()); + for (size_t i=0;i(MarkerDistance)+markerSizeFloat; + for (int y=0;y=int(ids.size())) throw cv::Exception(999," FiducidalMarkers::createMarkerMapImage_ChessMarkerMap","INTERNAL ERROR. REWRITE THIS!!",__FILE__,__LINE__); + TInfo.push_back( Marker3DInfo(ids[CurMarkerIdx++])); + /// \todo use const auto & + for(auto p:aruco::Marker::get3DPoints(markerSizeFloat)) + TInfo.back().points.push_back(p+cv::Point3f(x*markerSizeFloat,y*markerSizeFloat,0) ); + } + } + } + } + + // cv::Point3f center(0,0,0); + // double n=0; + // for(auto &ti:TInfo)for(auto p:ti) {center+=p;n++;} + // center*=1./n; + cv::Point3f center(gridSize.width/2.0f * markerSizeFloat - markerSizeFloat/2.0f, gridSize.height/2.0f * markerSizeFloat - markerSizeFloat/2.0f, 0.f); + for(auto &ti:TInfo) for(auto &p:ti.points) p-=center; + + + return TInfo; +} + +/** + * @brief Dictionary::computeDictionaryDistance + * @param dict + * @return + */ +uint64_t Dictionary::computeDictionaryDistance(const Dictionary &dict){ + + auto rotate=[](const cv::Mat &in) { + cv::Mat out; + in.copyTo(out); + for (int i = 0; i < in.rows; i++) { + for (int j = 0; j < in.cols; j++) { + out.at< uchar >(i, j) = in.at< uchar >(in.cols - j - 1, i); + } + } + return out; + }; + auto getImage=[](uint64_t tag,int nbits){ + std::bitset<64> bs(tag); + cv::Mat im(nbits,nbits,CV_8UC1); + int bit=(nbits*nbits)-1; + for(int i=0;i(i,j)=bs[bit--]; + return im; + }; + + auto getCode=[](const cv::Mat &in){ + assert(in.type()==CV_8UC1); + std::bitset<64> bs; + size_t bit= in.total()-1; + for(int i=0;i(i,j); + return bs.to_ullong(); + }; + + + //convert each element into its 4 rorations first + std::vector all_rotations; + + std::vector ids; + //for chilitag + auto code_id2=dict._code_id; + for(auto tag_id:code_id2){ + all_rotations.push_back(tag_id.first); + auto m=getImage(tag_id.first, static_cast(sqrt(dict._nbits))); + for(int i=0;i<3;i++) + { + m=rotate(m); + all_rotations.push_back(getCode(m)); + ids.push_back( tag_id.second); + } + assert( getCode(rotate(m))==tag_id.first ); + } + + //now, compute minimum distance + std::map >errors; + uint64_t mind=std::numeric_limits::max(); + for(size_t i=0;i(all_rotations[i]^all_rotations[j]).count(); + if(d==0){ + if ( errors[ids[i]].count(ids[j])==0 ){ + cerr<<" Dictionary::computeDictionaryDistance ERROR IN YOUR DICT!!!!!"< +#include #include #include @@ -55,24 +55,43 @@ namespace aruco public: // loads from a set of predefined ones enum DICT_TYPES: - uint64_t{ - ARUCO_MIP_36h12=0x8, //*** recommended - ARUCO=0x1, // original aruco dictionary. By default - ARUCO_MIP_25h7=0x2, - ARUCO_MIP_16h3=0x4, - ARTAG=0x10, // - ARTOOLKITPLUS=0x20, - ARTOOLKITPLUSBCH=0x40, // - TAG16h5=0x80, - TAG25h7=0x100, - TAG25h9=0x200, - TAG36h11=0x400, - TAG36h10=0x800, // april tags - CHILITAGS=0x1000, // chili tags dictionary . NOT RECOMMENDED. It has distance 0. Markers 806 and 682 should not be - // used!!! - CUSTOM=0x4000 , // for used defined dictionaries (using loadFromfile). - ALL_DICTS=0xFFFF - }; +// uint64_t{ +// ARUCO_MIP_36h12=0x8, //*** recommended +// ARUCO=0x1, // original aruco dictionary. By default +// ARUCO_MIP_25h7=0x2, +// ARUCO_MIP_16h3=0x4, +// ARTAG=0x10, // +// ARTOOLKITPLUS=0x20, +// ARTOOLKITPLUSBCH=0x40, // +// TAG16h5=0x80, +// TAG25h7=0x100, +// TAG25h9=0x200, +// TAG36h11=0x400, +// TAG36h10=0x800, // april tags +// CHILITAGS=0x1000, // chili tags dictionary . NOT RECOMMENDED. It has distance 0. Markers 806 and 682 should not be +// // used!!! +// CUSTOM=0x4000 , // for used defined dictionaries (using loadFromfile). +// ALL_DICTS=0xFFFF +// }; + + uint64_t{ + ALL_DICTS=0, + ARUCO_MIP_36h12=1, //*** recommended + ARUCO=2, // original aruco dictionary. By default + ARUCO_MIP_25h7=3, + ARUCO_MIP_16h3=4, + ARTAG=5, // + ARTOOLKITPLUS=6, + ARTOOLKITPLUSBCH=7, // + TAG16h5=8, + TAG25h7=9, + TAG25h9=10, + TAG36h11=11, + TAG36h10=12, // april tags + CHILITAGS=13, // chili tags dictionary . NOT RECOMMENDED. It has distance 0. Markers 806 and 682 should not be + // used!!! + CUSTOM=14 , // for used defined dictionaries (using loadFromfile). + }; // indicates if a code is in the dictionary bool is(uint64_t code) const { @@ -125,7 +144,7 @@ namespace aruco //@param bit_size of the image will be AxA, A=(nbits()+2)*bit_size //@param enclosed_corners if true, extra rectagles are added touching the marker corners. it can be used to //allow subpixel refinement - cv::Mat getMarkerImage_id(int id, int bit_size, bool addWaterMark = true, bool enclosed_corners = false,bool printExternalWhiteBorder=false); + cv::Mat getMarkerImage_id(int id, int bit_size, bool addWaterMark = true, bool enclosed_corners = false,bool printExternalWhiteBorder=false,bool centralCircle=false); // used for boards MarkerMap createMarkerMap(cv::Size gridSize, int MarkerSize, int MarkerDistance, const std::vector& Ids, diff --git a/src/aruco/ippe.cpp b/src/aruco/ippe.cpp new file mode 100644 index 0000000..b083ef4 --- /dev/null +++ b/src/aruco/ippe.cpp @@ -0,0 +1,580 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "ippe.h" +#include +#include +using namespace cv; +using namespace std; +namespace aruco { + +/****** + * + */ + +cv::Mat getRTMatrix(const cv::Mat& R_, const cv::Mat& T_, int forceType) +{ + cv::Mat M; + cv::Mat R, T; + R_.copyTo(R); + T_.copyTo(T); + if (R.type() == CV_64F) + { + assert(T.type() == CV_64F); + cv::Mat Matrix = cv::Mat::eye(4, 4, CV_64FC1); + + cv::Mat R33 = cv::Mat(Matrix, cv::Rect(0, 0, 3, 3)); + if (R.total() == 3) + { + cv::Rodrigues(R, R33); + } + else if (R.total() == 9) + { + cv::Mat R64; + R.convertTo(R64, CV_64F); + R.copyTo(R33); + } + for (int i = 0; i < 3; i++) + Matrix.at(i, 3) = T.ptr(0)[i]; + M = Matrix; + } + else if (R.depth() == CV_32F) + { + cv::Mat Matrix = cv::Mat::eye(4, 4, CV_32FC1); + cv::Mat R33 = cv::Mat(Matrix, cv::Rect(0, 0, 3, 3)); + if (R.total() == 3) + { + cv::Rodrigues(R, R33); + } + else if (R.total() == 9) + { + cv::Mat R32; + R.convertTo(R32, CV_32F); + R.copyTo(R33); + } + + for (int i = 0; i < 3; i++) + Matrix.at(i, 3) = T.ptr(0)[i]; + M = Matrix; + } + + if (forceType == -1) + return M; + else + { + cv::Mat MTyped; + M.convertTo(MTyped, forceType); + return MTyped; + } +} +vector solvePnP(const vector& objPoints, const std::vector& imgPoints, + cv::InputArray cameraMatrix, cv::InputArray distCoeffs) +{ + cv::Mat Rvec, Tvec; + float markerLength = static_cast(cv::norm(objPoints[1] - objPoints[0])); + float reprojErr1, reprojErr2; + cv::Mat Rvec2, Tvec2; + + solvePoseOfCentredSquare(markerLength, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec, reprojErr1, Rvec2, + Tvec2, reprojErr2); + return {getRTMatrix(Rvec, Tvec, CV_32F), getRTMatrix(Rvec2, Tvec2, CV_32F)}; +} + +void solvePnP(const vector& objPoints, const std::vector& imgPoints, + cv::InputArray cameraMatrix, cv::InputArray distCoeffs,cv::Mat &rvec,cv::Mat &tvec) +{ + float markerLength = static_cast(cv::norm(objPoints[1] - objPoints[0])); + float reprojErr1, reprojErr2; + cv::Mat Rvec2, Tvec2; + + solvePoseOfCentredSquare(markerLength, imgPoints, cameraMatrix, distCoeffs, rvec, tvec, reprojErr1, Rvec2, + Tvec2, reprojErr2); +} +std::vector > solvePnP_(float size,const std::vector &imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs){ + cv::Mat Rvec, Tvec, Rvec2,Tvec2; + float reprojErr1, reprojErr2; + solvePoseOfCentredSquare(size, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec,reprojErr1,Rvec2,Tvec2,reprojErr2); + return {make_pair(getRTMatrix(Rvec,Tvec,CV_32F),reprojErr1), make_pair(getRTMatrix(Rvec2,Tvec2,CV_32F),reprojErr2) } ; + + +} +std::vector> solvePnP_(const std::vector& objPoints, + const std::vector& imgPoints, + cv::InputArray cameraMatrix, cv::InputArray distCoeffs) +{ + cv::Mat Rvec, Tvec; + float markerLength = static_cast(cv::norm(objPoints[1] - objPoints[0])); + float reprojErr1, reprojErr2; + cv::Mat Rvec2, Tvec2; + + solvePoseOfCentredSquare(markerLength, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec, reprojErr1, Rvec2, + Tvec2, reprojErr2); + return {make_pair(getRTMatrix(Rvec, Tvec, CV_32F), reprojErr1), + make_pair(getRTMatrix(Rvec2, Tvec2, CV_32F), reprojErr2)}; +} + +void solvePoseOfCentredSquare(float squareLength, InputArray imagePoints, InputArray cameraMatrix, + InputArray distCoeffs, OutputArray _rvec1, OutputArray _tvec1, float& reprojErr1, + OutputArray _rvec2, OutputArray _tvec2, float& reprojErr2) +{ + cv::Mat undistortedPoints; // undistored version of imagePoints + cv::Mat modelPoints(4, 1, CV_32FC3); + // set coordinate system in the middle of the marker, with Z pointing out + modelPoints.ptr(0)[0] = Vec3f(-squareLength / 2.0f, squareLength / 2.0f, 0); + modelPoints.ptr(0)[1] = Vec3f(squareLength / 2.0f, squareLength / 2.0f, 0); + modelPoints.ptr(0)[2] = Vec3f(squareLength / 2.0f, -squareLength / 2.0f, 0); + modelPoints.ptr(0)[3] = Vec3f(-squareLength / 2.0f, -squareLength / 2.0f, 0); + + //(Ra,ta), (Rb,tb) are the two pose solutions from IPPE. + _rvec1.create(3, 1, CV_64FC1); + _tvec1.create(3, 1, CV_64FC1); + _rvec2.create(3, 1, CV_64FC1); + _tvec2.create(3, 1, CV_64FC1); + + cv::Mat H, Ra, Rb, ta, tb; + cv::Mat tvec1 = _tvec1.getMat(); + cv::Mat rvec1 = _rvec1.getMat(); + cv::Mat tvec2 = _tvec2.getMat(); + cv::Mat rvec2 = _rvec2.getMat(); + + // undistort the image points (i.e. put them in normalized pixel coordinates). + undistortPoints(imagePoints, undistortedPoints, cameraMatrix, distCoeffs); + + // compute the homography mapping the model's four corners to undistortedPoints + homographyFromSquarePoints(undistortedPoints, squareLength / 2.0f, H); + + // Compute the Jacobian J of the homography at (0,0): + double j00, j01, j10, j11, v0, v1; + + j00 = H.at(0, 0) - H.at(2, 0) * H.at(0, 2); + j01 = H.at(0, 1) - H.at(2, 1) * H.at(0, 2); + j10 = H.at(1, 0) - H.at(2, 0) * H.at(1, 2); + j11 = H.at(1, 1) - H.at(2, 1) * H.at(1, 2); + + // Compute the transformation of (0,0) into the image: + v0 = H.at(0, 2); + v1 = H.at(1, 2); + + // compute the two rotation solutions: + IPPComputeRotations(j00, j01, j10, j11, v0, v1, Ra, Rb); + + // for each rotation solution, compute the corresponding translation solution: + IPPComputeTranslation(modelPoints, undistortedPoints, Ra, ta); + IPPComputeTranslation(modelPoints, undistortedPoints, Rb, tb); + + float reprojErra = IPPEvalReprojectionError(Ra, ta, modelPoints, undistortedPoints); + float reprojErrb = IPPEvalReprojectionError(Rb, tb, modelPoints, undistortedPoints); + + if (reprojErra < reprojErrb) + { + tvec1.at(0) = ta.at(0); + tvec1.at(1) = ta.at(1); + tvec1.at(2) = ta.at(2); + IPPERot2vec(Ra, rvec1); + + tvec2.at(0) = tb.at(0); + tvec2.at(1) = tb.at(1); + tvec2.at(2) = tb.at(2); + IPPERot2vec(Rb, rvec2); + + reprojErr1 = reprojErra; + reprojErr2 = reprojErrb; + } + else + { + tvec1.at(0) = tb.at(0); + tvec1.at(1) = tb.at(1); + tvec1.at(2) = tb.at(2); + IPPERot2vec(Rb, rvec1); + + tvec2.at(0) = ta.at(0); + tvec2.at(1) = ta.at(1); + tvec2.at(2) = ta.at(2); + IPPERot2vec(Ra, rvec2); + + reprojErr1 = reprojErrb; + reprojErr2 = reprojErra; + } +} + +int IPPEvalBestPose(InputArray _R1, InputArray _R2, InputArray _t1, InputArray _t2, InputArray _objectPoints, + InputArray _undistortedPoints) +{ + cv::Mat modelPoints = _objectPoints.getMat(); + cv::Mat imgPoints = _undistortedPoints.getMat(); + + cv::Mat R1 = _R1.getMat(); + cv::Mat t1 = _t1.getMat(); + + cv::Mat R2 = _R2.getMat(); + cv::Mat t2 = _t2.getMat(); + + int numPts = modelPoints.rows; + + // now loop over each correspondence and compute the reprojection error of both pose solution + float px, py, pz; + float reprojError1 = 0; // reprojection error of pose 1 + float reprojError2 = 0; // reprojection error of pose 2 + + float dx, dy; // residual reprojection error with respect to x and y coordinates + for (int i = 0; i < numPts; i++) + { + // projection with first pose solution: + px = static_cast(R1.at(0, 0) * modelPoints.at(i)(0)) + + static_cast(R1.at(0, 1) * modelPoints.at(i)(1)) + + static_cast(R1.at(0, 2) * modelPoints.at(i)(2) + t1.at(0)); + py = static_cast(R1.at(1, 0) * modelPoints.at(i)(0)) + + static_cast(R1.at(1, 1) * modelPoints.at(i)(1)) + + static_cast(R1.at(1, 2) * modelPoints.at(i)(2) + t1.at(1)); + pz = static_cast(R1.at(2, 0) * modelPoints.at(i)(0)) + + static_cast(R1.at(2, 1) * modelPoints.at(i)(1)) + + static_cast(R1.at(2, 2) * modelPoints.at(i)(2) + t1.at(2)); + + dx = px / pz - imgPoints.at(i)(0); + dy = py / pz - imgPoints.at(i)(1); + + reprojError1 = reprojError1 + sqrt(dx * dx + dy * dy); + + // projection with second pose solution: + px = static_cast(R2.at(0, 0) * modelPoints.at(i)(0)) + + static_cast(R2.at(0, 1) * modelPoints.at(i)(1)) + + static_cast(R2.at(0, 2) * modelPoints.at(i)(2) + t2.at(0)); + py = static_cast(R2.at(1, 0) * modelPoints.at(i)(0)) + + static_cast(R2.at(1, 1) * modelPoints.at(i)(1)) + + static_cast(R2.at(1, 2) * modelPoints.at(i)(2) + t2.at(1)); + pz = static_cast(R2.at(2, 0) * modelPoints.at(i)(0)) + + static_cast(R2.at(2, 1) * modelPoints.at(i)(1)) + + static_cast(R2.at(2, 2) * modelPoints.at(i)(2) + t2.at(2)); + + dx = px / pz - imgPoints.at(i)(0); + dy = py / pz - imgPoints.at(i)(1); + + reprojError2 = reprojError2 + sqrt(dx * dx + dy * dy); + } + if (reprojError1 < reprojError2) + { + return 1; + } + else + { + return 2; + } +} + +float IPPEvalReprojectionError(InputArray _R, InputArray _t, InputArray _objectPoints, + InputArray _undistortedPoints) +{ + cv::Mat modelPoints = _objectPoints.getMat(); + cv::Mat imgPoints = _undistortedPoints.getMat(); + + cv::Mat R = _R.getMat(); + cv::Mat t = _t.getMat(); + + int numPts = modelPoints.rows; + float px, py, pz; + float reprojError = 0; + float dx, dy; // residual reprojection error with respect to x and y coordinates + // now loop over each correspondence and compute the reprojection error + for (int i = 0; i < numPts; i++) + { + px = static_cast(R.at(0, 0) * modelPoints.at(i)(0)) + + static_cast(R.at(0, 1) * modelPoints.at(i)(1)) + + static_cast(R.at(0, 2) * modelPoints.at(i)(2) + t.at(0)); + py = static_cast(R.at(1, 0) * modelPoints.at(i)(0)) + + static_cast(R.at(1, 1) * modelPoints.at(i)(1)) + + static_cast(R.at(1, 2) * modelPoints.at(i)(2) + t.at(1)); + pz = static_cast(R.at(2, 0) * modelPoints.at(i)(0)) + + static_cast(R.at(2, 1) * modelPoints.at(i)(1)) + + static_cast(R.at(2, 2) * modelPoints.at(i)(2) + t.at(2)); + + dx = px / pz - imgPoints.at(i)(0); + dy = py / pz - imgPoints.at(i)(1); + + reprojError = reprojError + sqrt(dx * dx + dy * dy); + } + return reprojError; +} + +void IPPERot2vec(InputArray _R, OutputArray _r) +{ + cv::Mat R = _R.getMat(); + cv::Mat rvec = _r.getMat(); + double trace = R.at(0, 0) + R.at(1, 1) + R.at(2, 2); + double w_norm = acos((trace - 1.0) / 2.0); + double c0, c1, c2; + double eps = std::numeric_limits::epsilon(); + double d = 1 / (2 * sin(w_norm)) * w_norm; + if (w_norm < eps) // rotation is the identity + { + rvec.setTo(0); + } + else + { + c0 = R.at(2, 1) - R.at(1, 2); + c1 = R.at(0, 2) - R.at(2, 0); + c2 = R.at(1, 0) - R.at(0, 1); + rvec.at(0) = d * c0; + rvec.at(1) = d * c1; + rvec.at(2) = d * c2; + } +} + +void IPPComputeTranslation(InputArray _objectPoints, InputArray _imgPoints, InputArray _R, OutputArray _t) +{ + // This is solved by building the linear system At = b, where t corresponds to the (ALL_DICTS) translation. + // This is then inverted with the associated normal equations to give t = inv(transpose(A)*A)*transpose(A)*b + // For efficiency we only store the coefficients of (transpose(A)*A) and (transpose(A)*b) + cv::Mat modelPoints = _objectPoints.getMat(); + cv::Mat imgPoints = _imgPoints.getMat(); + int numPts = modelPoints.rows; + + _t.create(3, 1, CV_64FC1); + + cv::Mat R = _R.getMat(); + + // coefficients of (transpose(A)*A) + double ATA00 = numPts; + double ATA02 = 0; + double ATA11 = numPts; + double ATA12 = 0; + double ATA20 = 0; + double ATA21 = 0; + double ATA22 = 0; + + // coefficients of (transpose(A)*b) + double ATb0 = 0; + double ATb1 = 0; + double ATb2 = 0; + + // S gives inv(transpose(A)*A)/det(A)^2 + double S00, S01, S02; + double S10, S11, S12; + double S20, S21, S22; + + double rx, ry, rz; + double a2; + double b2; + double bx, by; + + // now loop through each point and increment the coefficients: + for (int i = 0; i < numPts; i++) + { + rx = R.at(0, 0) * modelPoints.at(i)(0) + R.at(0, 1) * modelPoints.at(i)(1) + + R.at(0, 2) * modelPoints.at(i)(2); + ry = R.at(1, 0) * modelPoints.at(i)(0) + R.at(1, 1) * modelPoints.at(i)(1) + + R.at(1, 2) * modelPoints.at(i)(2); + rz = R.at(2, 0) * modelPoints.at(i)(0) + R.at(2, 1) * modelPoints.at(i)(1) + + R.at(2, 2) * modelPoints.at(i)(2); + a2 = -imgPoints.at(i)(0); + b2 = -imgPoints.at(i)(1); + ATA02 = ATA02 + a2; + ATA12 = ATA12 + b2; + ATA20 = ATA20 + a2; + ATA21 = ATA21 + b2; + ATA22 = ATA22 + a2 * a2 + b2 * b2; + bx = (imgPoints.at(i)(0)) * rz - rx; + by = (imgPoints.at(i)(1)) * rz - ry; + ATb0 = ATb0 + bx; + ATb1 = ATb1 + by; + ATb2 = ATb2 + a2 * bx + b2 * by; + } + + double detAInv = 1.0 / (ATA00 * ATA11 * ATA22 - ATA00 * ATA12 * ATA21 - ATA02 * ATA11 * ATA20); + + // construct S: + S00 = ATA11 * ATA22 - ATA12 * ATA21; + S01 = ATA02 * ATA21; + S02 = -ATA02 * ATA11; + S10 = ATA12 * ATA20; + S11 = ATA00 * ATA22 - ATA02 * ATA20; + S12 = -ATA00 * ATA12; + S20 = -ATA11 * ATA20; + S21 = -ATA00 * ATA21; + S22 = ATA00 * ATA11; + + // solve t: + Mat t = _t.getMat(); + t.at(0) = detAInv * (S00 * ATb0 + S01 * ATb1 + S02 * ATb2); + t.at(1) = detAInv * (S10 * ATb0 + S11 * ATb1 + S12 * ATb2); + t.at(2) = detAInv * (S20 * ATb0 + S21 * ATb1 + S22 * ATb2); +} + +void IPPComputeRotations(double j00, double j01, double j10, double j11, double p, double q, OutputArray _R1, + OutputArray _R2) +{ + // Note that it is very hard to understand what is going on here from the code, so if you want to have a clear + // explanation then please refer to the IPPE paper (Algorithm 1 and its description). + _R1.create(3, 3, CV_64FC1); + _R2.create(3, 3, CV_64FC1); + + double a00, a01, a10, a11, ata00, ata01, ata11, b00, b01, b10, b11, binv00, binv01, binv10, binv11; + double rv00, rv01, rv02, rv10, rv11, rv12, rv20, rv21, rv22; + double rtilde00, rtilde01, rtilde10, rtilde11; + double rtilde00_2, rtilde01_2, rtilde10_2, rtilde11_2; + double b0, b1, gamma, dtinv; + double s, t, sp, krs0, krs1, krs0_2, krs1_2, costh, sinth; + + s = sqrt(p * p + q * q + 1); + t = sqrt(p * p + q * q); + costh = 1 / s; + sinth = sqrt(1 - 1 / (s * s)); + + krs0 = p / t; + krs1 = q / t; + krs0_2 = krs0 * krs0; + krs1_2 = krs1 * krs1; + + rv00 = (costh - 1) * krs0_2 + 1; + rv01 = krs0 * krs1 * (costh - 1); + rv02 = krs0 * sinth; + rv10 = krs0 * krs1 * (costh - 1); + rv11 = (costh - 1) * krs1_2 + 1; + rv12 = krs1 * sinth; + rv20 = -krs0 * sinth; + rv21 = -krs1 * sinth; + rv22 = (costh - 1) * (krs0_2 + krs1_2) + 1; + + // setup the 2x2 SVD decomposition: + b00 = rv00 - p * rv20; + b01 = rv01 - p * rv21; + b10 = rv10 - q * rv20; + b11 = rv11 - q * rv21; + + dtinv = 1.0 / ((b00 * b11 - b01 * b10)); + + binv00 = dtinv * b11; + binv01 = -dtinv * b01; + binv10 = -dtinv * b10; + binv11 = dtinv * b00; + + a00 = binv00 * j00 + binv01 * j10; + a01 = binv00 * j01 + binv01 * j11; + a10 = binv10 * j00 + binv11 * j10; + a11 = binv10 * j01 + binv11 * j11; + + // compute the largest singular value of A: + ata00 = a00 * a00 + a01 * a01; + ata01 = a00 * a10 + a01 * a11; + ata11 = a10 * a10 + a11 * a11; + + gamma = sqrt(0.5 * (ata00 + ata11 + sqrt((ata00 - ata11) * (ata00 - ata11) + 4.0 * ata01 * ata01))); + + // reconstruct the full rotation matrices: + rtilde00 = a00 / gamma; + rtilde01 = a01 / gamma; + rtilde10 = a10 / gamma; + rtilde11 = a11 / gamma; + + rtilde00_2 = rtilde00 * rtilde00; + rtilde01_2 = rtilde01 * rtilde01; + rtilde10_2 = rtilde10 * rtilde10; + rtilde11_2 = rtilde11 * rtilde11; + + b0 = sqrt(-rtilde00_2 - rtilde10_2 + 1); + b1 = sqrt(-rtilde01_2 - rtilde11_2 + 1); + sp = (-rtilde00 * rtilde01 - rtilde10 * rtilde11); + + if (sp < 0) + { + b1 = -b1; + } + + // save results: + Mat R1 = _R1.getMat(); + Mat R2 = _R2.getMat(); + + R1.at(0, 0) = (rtilde00)*rv00 + (rtilde10)*rv01 + (b0)*rv02; + R1.at(0, 1) = (rtilde01)*rv00 + (rtilde11)*rv01 + (b1)*rv02; + R1.at(0, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv00 + (b0 * rtilde01 - b1 * rtilde00) * rv01 + + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv02; + R1.at(1, 0) = (rtilde00)*rv10 + (rtilde10)*rv11 + (b0)*rv12; + R1.at(1, 1) = (rtilde01)*rv10 + (rtilde11)*rv11 + (b1)*rv12; + R1.at(1, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv10 + (b0 * rtilde01 - b1 * rtilde00) * rv11 + + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv12; + R1.at(2, 0) = (rtilde00)*rv20 + (rtilde10)*rv21 + (b0)*rv22; + R1.at(2, 1) = (rtilde01)*rv20 + (rtilde11)*rv21 + (b1)*rv22; + R1.at(2, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv20 + (b0 * rtilde01 - b1 * rtilde00) * rv21 + + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv22; + + R2.at(0, 0) = (rtilde00)*rv00 + (rtilde10)*rv01 + (-b0) * rv02; + R2.at(0, 1) = (rtilde01)*rv00 + (rtilde11)*rv01 + (-b1) * rv02; + R2.at(0, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv00 + (b1 * rtilde00 - b0 * rtilde01) * rv01 + + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv02; + R2.at(1, 0) = (rtilde00)*rv10 + (rtilde10)*rv11 + (-b0) * rv12; + R2.at(1, 1) = (rtilde01)*rv10 + (rtilde11)*rv11 + (-b1) * rv12; + R2.at(1, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv10 + (b1 * rtilde00 - b0 * rtilde01) * rv11 + + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv12; + R2.at(2, 0) = (rtilde00)*rv20 + (rtilde10)*rv21 + (-b0) * rv22; + R2.at(2, 1) = (rtilde01)*rv20 + (rtilde11)*rv21 + (-b1) * rv22; + R2.at(2, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv20 + (b1 * rtilde00 - b0 * rtilde01) * rv21 + + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv22; +} + +void homographyFromSquarePoints(InputArray _targetPts, double halfLength, OutputArray H_) +{ + cv::Mat pts = _targetPts.getMat(); + H_.create(3, 3, CV_64FC1); + Mat H = H_.getMat(); + + double p1x = -pts.at(0)(0); + double p1y = -pts.at(0)(1); + + double p2x = -pts.at(1)(0); + double p2y = -pts.at(1)(1); + + double p3x = -pts.at(2)(0); + double p3y = -pts.at(2)(1); + + double p4x = -pts.at(3)(0); + double p4y = -pts.at(3)(1); + + // analytic solution: + double detsInv = -1 / (halfLength * (p1x * p2y - p2x * p1y - p1x * p4y + p2x * p3y - p3x * p2y + p4x * p1y + + p3x * p4y - p4x * p3y)); + + H.at(0, 0) = detsInv * (p1x * p3x * p2y - p2x * p3x * p1y - p1x * p4x * p2y + p2x * p4x * p1y + - p1x * p3x * p4y + p1x * p4x * p3y + p2x * p3x * p4y - p2x * p4x * p3y); + H.at(0, 1) = detsInv * (p1x * p2x * p3y - p1x * p3x * p2y - p1x * p2x * p4y + p2x * p4x * p1y + + p1x * p3x * p4y - p3x * p4x * p1y - p2x * p4x * p3y + p3x * p4x * p2y); + H.at(0, 2) = + detsInv * halfLength * (p1x * p2x * p3y - p2x * p3x * p1y - p1x * p2x * p4y + p1x * p4x * p2y - p1x * p4x * p3y + + p3x * p4x * p1y + p2x * p3x * p4y - p3x * p4x * p2y); + H.at(1, 0) = detsInv * (p1x * p2y * p3y - p2x * p1y * p3y - p1x * p2y * p4y + p2x * p1y * p4y + - p3x * p1y * p4y + p4x * p1y * p3y + p3x * p2y * p4y - p4x * p2y * p3y); + H.at(1, 1) = detsInv * (p2x * p1y * p3y - p3x * p1y * p2y - p1x * p2y * p4y + p4x * p1y * p2y + + p1x * p3y * p4y - p4x * p1y * p3y - p2x * p3y * p4y + p3x * p2y * p4y); + H.at(1, 2) = + detsInv * halfLength * (p1x * p2y * p3y - p3x * p1y * p2y - p2x * p1y * p4y + p4x * p1y * p2y - p1x * p3y * p4y + + p3x * p1y * p4y + p2x * p3y * p4y - p4x * p2y * p3y); + H.at(2, 0) = + -detsInv * (p1x * p3y - p3x * p1y - p1x * p4y - p2x * p3y + p3x * p2y + p4x * p1y + p2x * p4y - p4x * p2y); + H.at(2, 1) = + detsInv * (p1x * p2y - p2x * p1y - p1x * p3y + p3x * p1y + p2x * p4y - p4x * p2y - p3x * p4y + p4x * p3y); + H.at(2, 2) = 1.0; +} +} diff --git a/src/include/aruco/ippe.h b/src/aruco/ippe.h similarity index 97% rename from src/include/aruco/ippe.h rename to src/aruco/ippe.h index 2c2f9db..99e739d 100644 --- a/src/include/aruco/ippe.h +++ b/src/aruco/ippe.h @@ -42,7 +42,7 @@ or implied, of Rafael Muñoz Salinas. #ifndef _IPPE_H_ #define _IPPE_H_ -#include +#include #include "aruco_export.h" namespace aruco @@ -50,6 +50,8 @@ namespace aruco // returns the two solutions std::vector solvePnP(const std::vector& objPoints, const std::vector& imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs); + void solvePnP(const std::vector& objPoints, const std::vector& imgPoints, + cv::InputArray cameraMatrix, cv::InputArray distCoeffs,cv::Mat &rvec,cv::Mat &tvec); ARUCO_EXPORT std::vector > solvePnP_(float size,const std::vector &imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs); std::vector> solvePnP_(const std::vector& objPoints, diff --git a/src/include/aruco/levmarq.h b/src/aruco/levmarq.h similarity index 100% rename from src/include/aruco/levmarq.h rename to src/aruco/levmarq.h diff --git a/src/aruco/marker.cpp b/src/aruco/marker.cpp new file mode 100644 index 0000000..3daaaa4 --- /dev/null +++ b/src/aruco/marker.cpp @@ -0,0 +1,476 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "marker.h" + +/// \todo set this definition in the cmake code +#define _USE_MATH_DEFINES + +#include +#include + +#include +#include +#include "cameraparameters.h" +#include "ippe.h" + +namespace aruco +{ + /** + * + */ + Marker::Marker() + { + id = -1; + ssize = -1; + Rvec.create(3, 1, CV_32FC1); + Tvec.create(3, 1, CV_32FC1); + for (int i = 0; i < 3; i++) + Tvec.at(i, 0) = Rvec.at(i, 0) = -999999; + } + /** + * + */ + Marker::Marker(int _id) + { + id = _id; + ssize = -1; + Rvec.create(3, 1, CV_32FC1); + Tvec.create(3, 1, CV_32FC1); + for (int i = 0; i < 3; i++) + Tvec.at(i, 0) = Rvec.at(i, 0) = -999999; + } + /** + * + */ + Marker::Marker(const Marker& M) + : std::vector(M) + { + M.copyTo(*this); + } + + /** + * + */ + Marker::Marker(const std::vector& corners, int _id) + : std::vector(corners) + { + id = _id; + ssize = -1; + Rvec.create(3, 1, CV_32FC1); + Tvec.create(3, 1, CV_32FC1); + for (int i = 0; i < 3; i++) + Tvec.at(i, 0) = Rvec.at(i, 0) = -999999; + } + + void Marker::copyTo(Marker &m)const{ + m.id=id; + // size of the markers sides in meters + m.ssize=ssize; + // matrices of rotation and translation respect to the camera + Rvec.copyTo(m.Rvec ); + Tvec.copyTo(m.Tvec); + m.resize(size()); + for(size_t i=0;i(i, 0) != -999999) + invalid |= false; + if (Rvec.at(i, 0) != -999999) + invalid |= false; + } + if (invalid) + throw cv::Exception(9003, "extrinsic parameters are not set", "Marker::getModelViewMatrix", __FILE__, + __LINE__); + cv::Mat Rot(3, 3, CV_32FC1), Jacob; + cv::Rodrigues(Rvec, Rot, Jacob); + + double para[3][4]; + for (int i = 0; i < 3; i++) + for (int j = 0; j < 3; j++) + para[i][j] = Rot.at(i, j); + // now, add the translation + para[0][3] = Tvec.at(0, 0); + para[1][3] = Tvec.at(1, 0); + para[2][3] = Tvec.at(2, 0); + double scale = 1; + + modelview_matrix[0 + 0 * 4] = para[0][0]; + // R1C2 + modelview_matrix[0 + 1 * 4] = para[0][1]; + modelview_matrix[0 + 2 * 4] = para[0][2]; + modelview_matrix[0 + 3 * 4] = para[0][3]; + // R2 + modelview_matrix[1 + 0 * 4] = para[1][0]; + modelview_matrix[1 + 1 * 4] = para[1][1]; + modelview_matrix[1 + 2 * 4] = para[1][2]; + modelview_matrix[1 + 3 * 4] = para[1][3]; + // R3 + modelview_matrix[2 + 0 * 4] = -para[2][0]; + modelview_matrix[2 + 1 * 4] = -para[2][1]; + modelview_matrix[2 + 2 * 4] = -para[2][2]; + modelview_matrix[2 + 3 * 4] = -para[2][3]; + modelview_matrix[3 + 0 * 4] = 0.0; + modelview_matrix[3 + 1 * 4] = 0.0; + modelview_matrix[3 + 2 * 4] = 0.0; + modelview_matrix[3 + 3 * 4] = 1.0; + if (scale != 0.0) + { + modelview_matrix[12] *= scale; + modelview_matrix[13] *= scale; + modelview_matrix[14] *= scale; + } + } + + /**** + * + */ + void Marker::OgreGetPoseParameters(double position[3], double orientation[4]) + { + // check if paremeters are valid + bool invalid = false; + for (int i = 0; i < 3 && !invalid; i++) + { + if (Tvec.at(i, 0) != -999999) + invalid |= false; + if (Rvec.at(i, 0) != -999999) + invalid |= false; + } + if (invalid) + throw cv::Exception(9003, "extrinsic parameters are not set", "Marker::getModelViewMatrix", __FILE__, + __LINE__); + + // calculate position vector + position[0] = -Tvec.ptr(0)[0]; + position[1] = -Tvec.ptr(0)[1]; + position[2] = +Tvec.ptr(0)[2]; + + // now calculare orientation quaternion + cv::Mat Rot(3, 3, CV_32FC1); + cv::Rodrigues(Rvec, Rot); + + // calculate axes for quaternion + double stAxes[3][3]; + // x axis + stAxes[0][0] = -Rot.at(0, 0); + stAxes[0][1] = -Rot.at(1, 0); + stAxes[0][2] = +Rot.at(2, 0); + // y axis + stAxes[1][0] = -Rot.at(0, 1); + stAxes[1][1] = -Rot.at(1, 1); + stAxes[1][2] = +Rot.at(2, 1); + // for z axis, we use cross product + stAxes[2][0] = stAxes[0][1] * stAxes[1][2] - stAxes[0][2] * stAxes[1][1]; + stAxes[2][1] = -stAxes[0][0] * stAxes[1][2] + stAxes[0][2] * stAxes[1][0]; + stAxes[2][2] = stAxes[0][0] * stAxes[1][1] - stAxes[0][1] * stAxes[1][0]; + + // transposed matrix + double axes[3][3]; + axes[0][0] = stAxes[0][0]; + axes[1][0] = stAxes[0][1]; + axes[2][0] = stAxes[0][2]; + + axes[0][1] = stAxes[1][0]; + axes[1][1] = stAxes[1][1]; + axes[2][1] = stAxes[1][2]; + + axes[0][2] = stAxes[2][0]; + axes[1][2] = stAxes[2][1]; + axes[2][2] = stAxes[2][2]; + + // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes + // article "Quaternion Calculus and Fast Animation". + double fTrace = axes[0][0] + axes[1][1] + axes[2][2]; + double fRoot; + + if (fTrace > 0.0) + { + // |w| > 1/2, may as well choose w > 1/2 + fRoot = sqrt(fTrace + 1.0); // 2w + orientation[0] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; // 1/(4w) + orientation[1] = (axes[2][1] - axes[1][2]) * fRoot; + orientation[2] = (axes[0][2] - axes[2][0]) * fRoot; + orientation[3] = (axes[1][0] - axes[0][1]) * fRoot; + } + else + { + // |w| <= 1/2 + static unsigned int s_iNext[3] = {1, 2, 0}; + unsigned int i = 0; + if (axes[1][1] > axes[0][0]) + i = 1; + if (axes[2][2] > axes[i][i]) + i = 2; + unsigned int j = s_iNext[i]; + unsigned int k = s_iNext[j]; + + fRoot = sqrt(axes[i][i] - axes[j][j] - axes[k][k] + 1.0); + double* apkQuat[3] = {&orientation[1], &orientation[2], &orientation[3]}; + *apkQuat[i] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + orientation[0] = (axes[k][j] - axes[j][k]) * fRoot; + *apkQuat[j] = (axes[j][i] + axes[i][j]) * fRoot; + *apkQuat[k] = (axes[k][i] + axes[i][k]) * fRoot; + } + } + + void Marker::draw(cv::Mat& in, cv::Scalar color, int lineWidth, bool writeId, bool writeInfo) const + { + + auto _to_string=[](int i){ + std::stringstream str;str<(std::max(1.f, float(in.cols) / 1000.f)); + cv::line(in, (*this)[0], (*this)[1], color, lineWidth); + cv::line(in, (*this)[1], (*this)[2], color, lineWidth); + cv::line(in, (*this)[2], (*this)[3], color, lineWidth); + cv::line(in, (*this)[3], (*this)[0], color, lineWidth); + + auto p2 = cv::Point2f(2.f * static_cast(lineWidth), 2.f * static_cast(lineWidth)); + cv::rectangle(in, (*this)[0] - p2, (*this)[0] + p2, cv::Scalar(0, 0, 255, 255), -1); + cv::rectangle(in, (*this)[1] - p2, (*this)[1] + p2, cv::Scalar(0, 255, 0, 255), lineWidth); + cv::rectangle(in, (*this)[2] - p2, (*this)[2] + p2, cv::Scalar(255, 0, 0, 255), lineWidth); + + + + if (writeId) + { + // determine the centroid + cv::Point cent(0, 0); + for (int i = 0; i < 4; i++) + { + cent.x += static_cast((*this)[i].x); + cent.y += static_cast((*this)[i].y); + } + cent.x /= 4; + cent.y /= 4; + std::string str; + if(writeInfo) str+= dict_info +":"; + if(writeId)str+=_to_string(id); + cv::putText(in,str, cent, cv::FONT_HERSHEY_SIMPLEX, std::max(0.5f, float(lineWidth) * 0.3f), + cv::Scalar(255 - color[0], 255 - color[1], 255 - color[2], 255), std::max(lineWidth, 2)); + } + } + + /** + */ + void Marker::calculateExtrinsics(float markerSize, const CameraParameters& CP, + bool setYPerpendicular) + { + if (!CP.isValid()) + throw cv::Exception(9004, + "!CP.isValid(): invalid camera parameters. It is not possible to calculate extrinsics", + "calculateExtrinsics", __FILE__, __LINE__); + calculateExtrinsics(markerSize, CP.CameraMatrix, CP.Distorsion, setYPerpendicular); + } + + void print(cv::Point3f p, std::string cad) + { + std::cout << cad << " " << p.x << " " << p.y << " " << p.z << std::endl; + } + /** + */ + void Marker::calculateExtrinsics(float markerSizeMeters, cv::Mat camMatrix, cv::Mat distCoeff, + bool setYPerpendicular) + { + if (!isValid()) + throw cv::Exception(9004, "!isValid(): invalid marker. It is not possible to calculate extrinsics", + "calculateExtrinsics", __FILE__, __LINE__); + if (markerSizeMeters <= 0) + throw cv::Exception(9004, "markerSize<=0: invalid markerSize", "calculateExtrinsics", __FILE__, __LINE__); + if (camMatrix.rows == 0 || camMatrix.cols == 0) + throw cv::Exception(9004, "CameraMatrix is empty", "calculateExtrinsics", __FILE__, __LINE__); + + vector objpoints = get3DPoints(markerSizeMeters); + + + cv::Mat raux, taux; +// cv::solvePnP(objpoints, *this, camMatrix, distCoeff, raux, taux); + solvePnP(objpoints, *this,camMatrix, distCoeff,raux,taux); + raux.convertTo(Rvec, CV_32F); + taux.convertTo(Tvec, CV_32F); + // rotate the X axis so that Y is perpendicular to the marker plane + if (setYPerpendicular) + rotateXAxis(Rvec); + ssize = markerSizeMeters; + // cout<<(*this)<(0)[i]=setPrecision(Rvec.ptr(0)[i],100); +// Tvec.ptr(0)[i]=setPrecision(Tvec.ptr(0)[i],1000); +// } + + } + + std::vector Marker::get3DPoints(float msize) + { + float halfSize = msize / 2.f; +// std::vector res(4); +// res[0]=cv::Point3f(-halfSize, halfSize, 0); +// res[1]=cv::Point3f(halfSize, halfSize, 0); +// res[2]=cv::Point3f(halfSize,-halfSize, 0); +// res[3]=cv::Point3f(-halfSize,- halfSize, 0); +// return res; + return {cv::Point3f(-halfSize, halfSize, 0),cv::Point3f(halfSize, halfSize, 0),cv::Point3f(halfSize,-halfSize, 0),cv::Point3f(-halfSize, -halfSize, 0)}; + + } + + void Marker::rotateXAxis( cv::Mat& rotation) + { + cv::Mat R(3, 3, CV_32F); + cv::Rodrigues(rotation, R); + // create a rotation matrix for x axis + cv::Mat RX = cv::Mat::eye(3, 3, CV_32F); + const float angleRad = 3.14159265359f / 2.f; + RX.at(1, 1) = cos(angleRad); + RX.at(1, 2) = -sin(angleRad); + RX.at(2, 1) = sin(angleRad); + RX.at(2, 2) = cos(angleRad); + // now multiply + R = R * RX; + // finally, the the rodrigues back + Rodrigues(R, rotation); + } + + /** + */ + cv::Point2f Marker::getCenter() const + { + cv::Point2f cent(0, 0); + for (size_t i = 0; i < size(); i++) + { + cent.x += (*this)[i].x; + cent.y += (*this)[i].y; + } + cent.x /= float(size()); + cent.y /= float(size()); + return cent; + } + + /** + */ + float Marker::getArea() const + { + assert(size() == 4); + // use the cross products + cv::Point2f v01 = (*this)[1] - (*this)[0]; + cv::Point2f v03 = (*this)[3] - (*this)[0]; + float area1 = fabs(v01.x * v03.y - v01.y * v03.x); + cv::Point2f v21 = (*this)[1] - (*this)[2]; + cv::Point2f v23 = (*this)[3] - (*this)[2]; + float area2 = fabs(v21.x * v23.y - v21.y * v23.x); + return (area2 + area1) / 2.f; + } + /** + */ + float Marker::getPerimeter() const + { + assert(size() == 4); + float sum = 0; + for (int i = 0; i < 4; i++) + sum += static_cast(norm((*this)[i] - (*this)[(i + 1) % 4])); + return sum; + } + + + // saves to a binary stream + void Marker::toStream(std::ostream& str) const + { + assert(Rvec.type() == CV_32F && Tvec.type() == CV_32F); + str.write((char*)&id, sizeof(id)); + str.write((char*)&ssize, sizeof(ssize)); + str.write((char*)Rvec.ptr(0), 3 * sizeof(float)); + str.write((char*)Tvec.ptr(0), 3 * sizeof(float)); + // write the 2d points + uint32_t np = static_cast (size()); + str.write((char*)&np, sizeof(np)); + for (size_t i = 0; i < size(); i++) + str.write((char*)&at(i), sizeof(cv::Point2f)); + //write the additional info + uint32_t s=dict_info.size(); + str.write((char*)&s, sizeof(s)); + str.write((char*)&dict_info[0], dict_info.size()); + s=contourPoints.size(); + str.write((char*)&s, sizeof(s)); + str.write((char*)&contourPoints[0], contourPoints.size()*sizeof(contourPoints[0])); + + } + // reads from a binary stream + void Marker::fromStream(std::istream& str) + { + Rvec.create(1, 3, CV_32F); + Tvec.create(1, 3, CV_32F); + str.read((char*)&id, sizeof(id)); + str.read((char*)&ssize, sizeof(ssize)); + str.read((char*)Rvec.ptr(0), 3 * sizeof(float)); + str.read((char*)Tvec.ptr(0), 3 * sizeof(float)); + uint32_t np; + str.read((char*)&np, sizeof(np)); + resize(np); + for (size_t i = 0; i < size(); i++) + str.read((char*)&(*this)[i], sizeof(cv::Point2f)); + //read the additional info + uint32_t s; + str.read((char*)&s, sizeof(s)); + dict_info.resize(s); + str.read((char*)&dict_info[0], dict_info.size()); + str.read((char*)&s, sizeof(s)); + contourPoints.resize(s); + str.read((char*)&contourPoints[0], contourPoints.size()*sizeof(contourPoints[0])); + } + + +} diff --git a/src/include/aruco/marker.h b/src/aruco/marker.h similarity index 98% rename from src/include/aruco/marker.h rename to src/aruco/marker.h index b95af42..1d998cf 100644 --- a/src/include/aruco/marker.h +++ b/src/aruco/marker.h @@ -31,7 +31,7 @@ or implied, of Rafael Muñoz Salinas. #include "aruco_export.h" -#include +#include #include #include @@ -55,6 +55,8 @@ or implied, of Rafael Muñoz Salinas. cv::Mat Rvec, Tvec; //additional info about the dictionary std::string dict_info; + //points of the contour + vector contourPoints; /** */ diff --git a/src/aruco/markerdetector.cpp b/src/aruco/markerdetector.cpp new file mode 100644 index 0000000..2b1e2a7 --- /dev/null +++ b/src/aruco/markerdetector.cpp @@ -0,0 +1,1649 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "markerdetector.h" +#include "cameraparameters.h" +#include "markerlabeler.h" +#include "timers.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "debug.h" +//#include "picoflann.h" + +#ifdef _DEBUG +#include +#endif +using namespace std; +using namespace cv; + +namespace aruco +{ +/************************************ + * + * + * + * + ************************************/ +MarkerDetector::MarkerDetector() +{ + markerIdDetector = aruco::MarkerLabeler::create(Dictionary::ALL_DICTS); + setDetectionMode(DM_NORMAL); +} +/************************************ + * + * + * + * + ************************************/ +MarkerDetector::MarkerDetector(int dict_type, float error_correction_rate ){ + setDictionary(dict_type,error_correction_rate); + setDetectionMode(DM_NORMAL); +} +/************************************ + * + * + * + * + ************************************/ +MarkerDetector::MarkerDetector(std::string dict_type, float error_correction_rate ){ + setDictionary(dict_type,error_correction_rate); + setDetectionMode(DM_NORMAL); + +} +/************************************ + * + * + * + * + ************************************/ + +MarkerDetector::~MarkerDetector() +{ +} + +void MarkerDetector::setParameters(const Params ¶ms){ + _params=params; + setDictionary(_params.dictionary,_params.error_correction_rate); +} + +/************************************ + * + * + * + * + ************************************/ +void MarkerDetector::setDetectionMode( DetectionMode dm,float minMarkerSize){ + _params.setDetectionMode(dm,minMarkerSize); +} + +DetectionMode MarkerDetector::getDetectionMode( ){ +return _params.detectMode; +} + + + +/************************************ + * + * + * + * + ************************************/ + +std::vector MarkerDetector::detect(const cv::Mat& input) +{ + std::vector detectedMarkers; + detect(input, detectedMarkers); + return detectedMarkers; +} + +std::vector MarkerDetector::detect(const cv::Mat& input, const CameraParameters& camParams, + float markerSizeMeters, + bool setYPerperdicular) +{ + std::vector detectedMarkers; + detect(input, detectedMarkers, camParams, markerSizeMeters, setYPerperdicular); + return detectedMarkers; +} + +/************************************ + * + * + * + * + ************************************/ +void MarkerDetector::detect(const cv::Mat& input, std::vector& detectedMarkers, CameraParameters camParams, + float markerSizeMeters, bool setYPerpendicular) +{ + if (camParams.CamSize != input.size() && camParams.isValid() && markerSizeMeters > 0) + { + // must resize camera parameters if we want to compute properly marker poses + CameraParameters cp_aux = camParams; + cp_aux.resize(input.size()); + detect(input, detectedMarkers, cp_aux.CameraMatrix, cp_aux.Distorsion, markerSizeMeters, setYPerpendicular); + } + else + { + detect(input, detectedMarkers, camParams.CameraMatrix, camParams.Distorsion, markerSizeMeters,setYPerpendicular); + } +} +int MarkerDetector::getMarkerWarpSize(){ + + auto bis=markerIdDetector->getBestInputSize(); + if ( bis!=-1) return bis; + + int ndiv= markerIdDetector->getNSubdivisions(); + if (ndiv==-1) ndiv=7;//set any possible value(it is used for non dictionary based labelers) + return _params.markerWarpPixSize*ndiv;//this is the minimum size that the smallest marker will have + +} + + + + + +void MarkerDetector::buildPyramid(vector &ImagePyramid,const cv::Mat &grey,int minSize){ + //determine numbre of pyramid images + int npyrimg=1; + cv::Size imgpsize=grey.size(); + while (imgpsize.width > minSize) { imgpsize=cv::Size(imgpsize.width/_params.pyrfactor,imgpsize.height/_params.pyrfactor) ;npyrimg++;} + + ImagePyramid.resize(npyrimg); + imagePyramid[0]=grey; + //now, create pyramid images + imgpsize=grey.size(); + for(int i=1;i& kpoints, bool norm, int wsize) + { + if(im.type()!=CV_8UC1)throw std::runtime_error("assignClass_fast Input image must be 8UC1"); + int wsizeFull=wsize*2+1; + + cv::Mat labels = cv::Mat::zeros(wsize*2+1,wsize*2+1,CV_8UC1); + cv::Mat thresIm=cv::Mat(wsize*2+1,wsize*2+1,CV_8UC1); + + for(auto &kp:kpoints) + { + int x = kp.pt.x+0.5f; + int y = kp.pt.y+0.5f; + + cv::Rect r= cv::Rect(x-wsize,y-wsize,wsize*2+1,wsize*2+1); + //Check boundaries + if(r.x<0 || r.x+r.width>im.cols || r.y<0 || r.y+r.height>im.rows) continue; + + + int endX=r.x+r.width; + int endY=r.y+r.height; + uchar minV=255,maxV=0; + for(int y=r.y; y(y); + for(int x=r.x; xptr[x]) minV=ptr[x]; + if(maxV( r.y+y)+r.x; + uchar *thresPtr= thresIm.ptr(y); + for(int x=0; xthres) { + nZ++; + thresPtr[x]=255; + } + else thresPtr[x]=0; + } + } + //set all to zero labels.setTo(cv::Scalar::all(0)); + for(int y=0; y(y); + for(int x=0; x unions; + for(int y=0; y(y); + uchar *labelsPtr=labels.ptr(y); + for(int x=0; x -1) + { + if(reg == thresPtr[x-1]) + lleft_px =labelsPtr[x-1]; + } + + if(y-1 > -1) + { + if(reg ==thresIm.ptr(y-1) [x] )//thresIm.at(y-1, x) + ltop_px = labels.at(y-1, x); + } + + if(lleft_px==0 && ltop_px==0) + labelsPtr[x] = newLab++; + + else if(lleft_px!=0 && ltop_px!=0) + { + if(lleft_px < ltop_px) + { + labelsPtr[x] = lleft_px; + unions[ltop_px] = lleft_px; + } + else if(lleft_px > ltop_px) + { + labelsPtr[x] = ltop_px; + unions[lleft_px] = ltop_px; + } + else + {//IGuales + labelsPtr[x] = ltop_px; + } + } + else + { + if(lleft_px!=0) labelsPtr[x] = lleft_px; + else labelsPtr[x] = ltop_px; + } + } + } + + int nc= newLab-1 - unions.size(); + if(nc==2) + { + if(nZ > thresIm.total()-nZ) kp.class_id = 0; + else kp.class_id = 1; + } + else if (nc > 2) { + kp.class_id = 2; + + + } + } + } + +//void fastCorners{ +// vector kpts; +// cv::FAST(input,kpts,7); + +// // Adapter. +// // Given an Point2f element, it returns the element of the dimension specified such that dim=0 is x and dim=1 is y +// struct PicoFlann_Point2fAdapter{ +// inline float operator( )(const cv::KeyPoint &kp, int dim)const { return dim==0?kp.pt.x:kp.pt.y; } +// }; + +// picoflann::KdTreeIndex<2,PicoFlann_Point2fAdapter> kdtree;//2 is the number of dimensions +// kdtree.build(kpts); +// //search 10 nearest neibors to point (0,0) +// vector maxima(kpts.size(),true); +// for(auto &kpt:kpts){ +// kpt.size=1;//used +// kpt.class_id=-1;//not yet +// } + +// int classIdx=0; +// vector > center_weight; +// center_weight.reserve(kpts.size()); + +// for(size_t i=0;i > res=kdtree.radiusSearch(kpts,kpts[i],7); +// //compute the one with max response +// for(auto p:res){ +// if( kpts[p.first].response>= kpts[maxResponseIdx].response && kpts[p.first].size) +// maxResponseIdx= p.first ; +// } +// auto &maxKp=kpts[ maxResponseIdx]; + +// if(maxKp.class_id==-1){ +// maxKp.class_id=int(center_weight.size()); +// center_weight.push_back( { maxKp.pt*maxKp.response,maxKp.response}); +// } + +// //the others are non maxima +// for(auto p:res){ +// if(p.first==maxResponseIdx) continue; +// auto &kp=kpts[p.first]; +// if( kp.size!=0 && kp.class_id==-1){ +// kp.size=0;//sets as non maxiima +// center_weight[maxKp.class_id].first+=kp.pt*kp.response; +// center_weight[maxKp.class_id].second+=kp.response; +// } +// } +// } +// } + +// //take only the selected ones +// kpts.clear(); +// for(auto cw:center_weight){ +// cv::KeyPoint kp; +// kp.pt= cw.first*(1./cw.second); +// kpts.push_back(kp); +// } + +//// kpts.erase(std::remove_if(kpts.begin(),kpts.end(), [ ](const cv::KeyPoint &kp){return kp.class_id==0;}), kpts.end()); + +// assignClass_fast(input,kpts,false,5); + + +// cv::Mat im2; +// cv::cvtColor(input,im2,CV_GRAY2BGR); +// for(int i=0;i< kpts.size();i++){ +// auto & kp=kpts[i]; + +// if(kp.class_id==2){ + +// cv::rectangle(auxThresImage,kp.pt-cv::Point2f(2,2),kp.pt+cv::Point2f(2,2),cv::Scalar(0,0,0),-1); +// cv::rectangle(im2,kp.pt-cv::Point2f(2,2),kp.pt+cv::Point2f(2,2),cv::Scalar(255,0,123)); +// } +// else +// cv::rectangle(im2,kp.pt-cv::Point2f(2,2),kp.pt+cv::Point2f(2,2),cv::Scalar(125,125,125)); +// } + +//} +/************************************************** + * + */ + +vector< MarkerDetector::MarkerCandidate> MarkerDetector::thresholdAndDetectRectangles(const cv::Mat & input, int thres_param1,int thres_param2,bool enclosed,cv::Mat &auxThresImage){ + // ensure that _thresParam1%2==1 + ScopedTimerEvents tev("hafc "); + if (thres_param1 < 3) thres_param1 = 3; + else if (((int)thres_param1) % 2 != 1) thres_param1 = (int)(thres_param1 + 1); + + int enclosedOffset=-1; + cv::Mat auxImage; + //if ( !erode) + auxImage=auxThresImage; + if (_params.thresMethod==THRES_AUTO_FIXED){ + cv::threshold(input, auxImage, static_cast(thres_param2),255,THRESH_BINARY_INV); + if(enclosed){ + cv::Mat aux1; + enclosedOffset=int(std::max(3.0, 3./1920. * float(auxImage.cols) )); + if (enclosedOffset%2==0) enclosedOffset++; + cv::erode(auxImage,aux1, getStructuringElement( MORPH_CROSS,cv::Size( enclosedOffset, enclosedOffset ),cv::Point( enclosedOffset/2,enclosedOffset/2 ) )); + cv::bitwise_xor(aux1,auxImage,auxImage); + tev.add("erode"); + } + } + else { + cv::adaptiveThreshold(input, auxImage, 255., ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY_INV, static_cast(thres_param1), static_cast(thres_param2)); + enclosedOffset=thres_param1; + } + tev.add("thres"); + + +//fastCorners () + + + vector MarkerCanditates; + // calcualte the min_max contour sizes + int thisImageMinSize=int( 3.5*float(_params.lowResMarkerSize)); + //if image is eroded, minSize must be adapted + std::vector hierarchy; + std::vector> contours; + cv::findContours(auxThresImage, contours, cv::noArray(), CV_RETR_LIST, CV_CHAIN_APPROX_NONE); + tev.add("find-cont"); + vector approxCurve; +//#define _aruco_debug_detectrectangles +#ifdef _aruco_debug_detectrectangles + cv::Mat simage; + cv::cvtColor(input,simage,CV_GRAY2BGR); +#endif + + /// for each contour, analyze if it is a paralelepiped likely to be the marker + for (unsigned int i = 0; i < contours.size(); i++) + { +#ifdef _aruco_debug_detectrectangles + drawContour(simage, contours[i], Scalar(125, 125, 255) ); +#endif + // check it is a possible element by first checking that is is large enough + if (thisImageMinSize < int(contours[i].size()) ) + { + // can approximate to a convex rect? + cv::approxPolyDP(contours[i], approxCurve, double(contours[i].size()) * 0.05, true); + + if (approxCurve.size() == 4 && cv::isContourConvex(approxCurve)) + { +#ifdef _aruco_debug_detectrectangles + drawApproxCurve(simage, approxCurve, Scalar(255, 0, 255),1); +#endif + // ensure that the distace between consecutive points is large enough + float minDist = std::numeric_limits::max(); + for (int j = 0; j < 4; j++) + { + float d = cv::norm(approxCurve[j]-approxCurve[(j + 1) % 4] ); + if (d < minDist) minDist = d; + } + + // add the points + MarkerCanditates.push_back(MarkerCandidate()); + for (int j = 0; j < 4; j++) + MarkerCanditates.back().push_back( Point2f(static_cast(approxCurve[j].x),static_cast(approxCurve[j].y))); + //now, if it is eroded, must enalrge 1 bit the corners to go to the real location + //for each opposite pair, take the line joining them and move one pixel apart + //ideally, Bresenham's algorithm should be used + if (enclosed) { + enlargeMarkerCandidate(MarkerCanditates.back(),float(enclosedOffset)/2.); + } +#ifdef _aruco_debug_detectrectangles + MarkerCanditates.back().draw(simage,Scalar(255, 255, 0),1,false); +#endif + MarkerCanditates.back().contour=contours[i]; + + } + + } + } +#ifdef _aruco_debug_detectrectangles + cv::imshow("contours",simage); +#endif + return MarkerCanditates; +} + + +void MarkerDetector::thresholdAndDetectRectangles_thread( ){ + while(true){ + //stringstream sstr;sstr<<"thread-"< MarkerDetector::thresholdAndDetectRectangles(const cv::Mat &image ){ + + // compute the different values of param1 + + int adaptiveWindowSize=_params.AdaptiveThresWindowSize; + if (_params.AdaptiveThresWindowSize==-1) + adaptiveWindowSize=max(int(3),int(15*float(image.cols)/1920.)); + if(adaptiveWindowSize%2==0)adaptiveWindowSize++; + + + vector p1_values; + for (int i = static_cast(std::max(3., adaptiveWindowSize- 2. * _params.AdaptiveThresWindowSize_range)); i <= adaptiveWindowSize + 2 * _params.AdaptiveThresWindowSize_range; i += 2) + p1_values.push_back(i); + + size_t nimages=p1_values.size(); + _tooNearDistance=p1_values.back(); + _vcandidates.resize(nimages); + _thres_Images.resize(nimages+1); + _thres_Images.back()=image; //add at the end the original image + //first, thresholded images + ThresAndDetectRectTASK tad; + vector vtad; + + + ThreadTasks task=THRESHOLD_TASK; + if (_params.enclosedMarker) task=ENCLOSE_TASK; + for (size_t i = 0; i < p1_values.size(); i++){ + tad.inIdx=int(_thres_Images.size()-1); + tad.param1=p1_values[i]; + tad.param2=_params.ThresHold; + tad.outIdx=i; + tad.task=task; + _tasks.push(tad); + vtad.push_back(tad); + } + + + //reserve images + for(size_t i=0;i threads; + for(int i=0;i joined; + joinVectors( _vcandidates,joined); + return joined; + +} + +vector< MarkerDetector::MarkerCandidate> MarkerDetector::prefilterCandidates( vector &MarkerCanditates,cv::Size imgSize){ + ///////////////////////////////////////////////////////////////////////////////////// + /// CANDIDATE PREFILTERING- Merge and Remove candidates so that only reliable ones are returned + ////////////////////////////////////////////////////////////////////////////////// + /// sort the points in anti-clockwise order + valarray swapped(false, MarkerCanditates.size()); // used later + for (unsigned int i = 0; i < MarkerCanditates.size(); i++) + { + // trace a line between the first and second point. + // if the thrid point is at the right side, then the points are anti-clockwise + double dx1 = MarkerCanditates[i][1].x - MarkerCanditates[i][0].x; + double dy1 = MarkerCanditates[i][1].y - MarkerCanditates[i][0].y; + double dx2 = MarkerCanditates[i][2].x - MarkerCanditates[i][0].x; + double dy2 = MarkerCanditates[i][2].y - MarkerCanditates[i][0].y; + double o = (dx1 * dy2) - (dy1 * dx2); + + if (o < 0.0) + { // if the third point is in the left side, then sort in anti-clockwise order + swap(MarkerCanditates[i][1], MarkerCanditates[i][3]); + swapped[i] = true; + } + } + /// remove these elements which corners are too close to each other + // first detect candidates to be removed + vector> TooNearCandidates; + for (unsigned int i = 0; i < MarkerCanditates.size(); i++) + { + // calculate the average distance of each corner to the nearest corner of the other marker candidate + for (unsigned int j = i + 1; j < MarkerCanditates.size(); j++) + { + valarray vdist(4); + for (int c = 0; c < 4; c++) + vdist[c] =cv::norm( MarkerCanditates[i][c] -MarkerCanditates[j][c]); + // if distance is too small + if (vdist[0] < _tooNearDistance && vdist[1] < _tooNearDistance && vdist[2] < _tooNearDistance && vdist[3] < _tooNearDistance) + TooNearCandidates.push_back(pair(i, j)); + } + } + + /// mark for removal the element of the pair with smaller perimeter + vector toRemove( MarkerCanditates.size(),false); + for (unsigned int i = 0; i < TooNearCandidates.size(); i++) + { + if (perimeter(MarkerCanditates[TooNearCandidates[i].first]) > perimeter(MarkerCanditates[TooNearCandidates[i].second])) + toRemove[TooNearCandidates[i].second] = true; + else + toRemove[TooNearCandidates[i].first] = true; + } + + /// find these too near borders and remove them + // remove markers with corners too near the image limits + int borderDistThresX = static_cast(_params.borderDistThres * float(imgSize.width)); + int borderDistThresY = static_cast(_params.borderDistThres * float(imgSize.height)); + for (size_t i = 0; i < MarkerCanditates.size(); i++) + { + // delete if any of the corners is too near image border + for (size_t c = 0; c < MarkerCanditates[i].size(); c++) + { + if (MarkerCanditates[i][c].x < borderDistThresX || MarkerCanditates[i][c].y < borderDistThresY + || MarkerCanditates[i][c].x > imgSize.width - borderDistThresX + || MarkerCanditates[i][c].y > imgSize.height - borderDistThresY) + { + toRemove[i] = true; + } + } + } + + //move to output only valid ones + vector finalCandidates; + finalCandidates.reserve(MarkerCanditates.size()); + for(size_t i=0;i&hist) +{ + for(int y=0;y(y); + for(int x=0;x &hist){ + float sum=0,invsum; + for(auto c:hist) sum+=c; + invsum=1./sum; + for(auto &c:hist) c*=invsum; + + float maxVar=0; + int bestT=-1; + for(int t=1;t<256;t++){ + float w0=0,w1=0,mean0=0,mean1=0; + for(int v=0;v1e-4 && w1>1e-4){ + mean0/=w0; + mean1/=w1; + float var=w0*w1*(mean0-mean1)*(mean0-mean1); + //cout<maxVar){ + maxVar=var; + bestT=t; + } + } + + } + return bestT; +} +/************************************ + * Main detection function. Performs all steps + ************************************/ +void MarkerDetector::detect(const cv::Mat& input, vector& detectedMarkers, Mat camMatrix, Mat distCoeff, + float markerSizeMeters, bool setYPerpendicular) +{ + // clear input data + detectedMarkers.clear(); + _vcandidates.clear(); + _candidates.clear(); + ScopedTimerEvents Timer("detect"); + + + // it must be a 3 channel image + if (input.type() == CV_8UC3) + cv::cvtColor(input,grey,CV_BGR2GRAY); + // convertToGray(input, grey); + else grey = input; + Timer.add("ConvertGrey"); + + ////////////////////////////////////////////////////////////////////// + ///CREATE LOW RESOLUTION IMAGE IN WHICH MARKERS WILL BE DETECTED + ////////////////////////////////////////////////////////////////////// + float ResizeFactor=1; + //use the minimum and markerWarpSize to determine the optimal image size on which to do rectangle detection + cv::Mat imgToBeThresHolded ; + cv::Size maxImageSize=grey.size(); + auto minpixsize=getMinMarkerSizePix(input.size());//min pixel size of the marker in the original image + if ( _params.lowResMarkerSize1) + buildPyramidThread=std::thread([&]{buildPyramid(imagePyramid,grey ,2*getMarkerWarpSize());}); + else buildPyramid(imagePyramid,grey,2*getMarkerWarpSize()); + Timer.add("BuildPyramid"); + } + else{ + imagePyramid.resize(1); + imagePyramid[0]=grey; + } + + + int nAttemptsAutoFix=0; + bool keepLookingFor=false; + std::vector hist(256,0); + do{ + /////////////////////////////////////////////////////////////////////////// + /// THRESHOLD IMAGES AND DETECT INITIAL RECTANGLES + /////////////////////////////////////////////////////////////////////////// + vector MarkerCanditates; + MarkerCanditates=thresholdAndDetectRectangles(imgToBeThresHolded ); + thres =_thres_Images[0]; + + _debug_exec(10, + {//only executes when compiled in DEBUG mode if debug level is at least 10 + //show the thresholded images + for (size_t i = 0; i < _thres_Images.size(); i++) { + stringstream sstr; sstr << "thres-" << i; + cv::namedWindow(sstr.str(),cv::WINDOW_NORMAL); + cv::imshow(sstr.str(),_thres_Images[i]); + }}); + + + Timer.add("Threshold and Detect rectangles"); + //prefilter candidates + _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 + //show the thresholded images + cv::Mat imrect; + cv::cvtColor(imgToBeThresHolded,imrect,CV_GRAY2BGR); + for(auto m: MarkerCanditates ) + m.draw(imrect,cv::Scalar(0,245,0)); + cv::imshow("rect-nofiltered",imrect); + ); + + MarkerCanditates=prefilterCandidates(MarkerCanditates,imgToBeThresHolded.size()); + + Timer.add("prefilterCandidates"); + + _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 + //show the thresholded images + cv::Mat imrect; + cv::cvtColor(imgToBeThresHolded,imrect,CV_GRAY2BGR); + for(auto m: MarkerCanditates) + m.draw(imrect,cv::Scalar(0,245,0)); + cv::imshow("rect-filtered",imrect); + ); + //before going on, make sure the piramid is built + if (buildPyramidThread.joinable()) + buildPyramidThread.join(); + + + /////////////////////////////////////////////////////////////////////////// + /// CANDIDATE CLASSIFICATION: Decide which candidates are really markers + /////////////////////////////////////////////////////////////////////////// + + // Debug::setLevel(10); + auto markerWarpSize=getMarkerWarpSize(); + + detectedMarkers.clear(); + _candidates.clear(); + for(auto &b:hist) b=0; + float desiredarea = std::pow(static_cast(markerWarpSize), 2.f); + for (size_t i = 0; i < MarkerCanditates.size(); i++) + { + // Find proyective homography + cv::Mat canonicalMarker,canonicalMarkerAux; + + cv::Mat inToWarp=imgToBeThresHolded; + MarkerCandidate points2d_pyr = MarkerCanditates[i]; + if (needPyramid){ + // warping is one of the most time consuming operations, especially when the region is large. + // To reduce computing time, let us find in the image pyramid, the best configuration to save time + // indicates how much bigger observation is wrt to desired patch + size_t imgPyrIdx = 0; + for (size_t p = 1; p < imagePyramid.size(); p++) + { + if (MarkerCanditates[i].getArea() / pow(4, p) >= desiredarea) imgPyrIdx = p; + else break; + } + inToWarp=imagePyramid[imgPyrIdx]; + //move points to the image level p + float ratio=float(inToWarp.cols)/float(imgToBeThresHolded.cols); + for (auto& p : points2d_pyr) p *= ratio;//1. / pow(2, imgPyrIdx); + + } + warp( inToWarp, canonicalMarker, Size(markerWarpSize,markerWarpSize),points2d_pyr); + int id, nRotations; + double min,Max; + cv::minMaxIdx(canonicalMarker,&min,&Max); + canonicalMarker.copyTo(canonicalMarkerAux); + string additionalInfo; + _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 + //show the thresholded images + stringstream sstr;sstr<<"test-"<detect(canonicalMarkerAux, id, nRotations,additionalInfo)) + { + detectedMarkers.push_back(MarkerCanditates[i]); + detectedMarkers.back().id = id; + detectedMarkers.back().dict_info=additionalInfo; + detectedMarkers.back().contourPoints=MarkerCanditates[i].contour; + // sort the points so that they are always in the same order no matter the camera orientation + std::rotate(detectedMarkers.back().begin(), + detectedMarkers.back().begin() + 4 - nRotations, + detectedMarkers.back().end()); + _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 + //show the thresholded images + stringstream sstr;sstr<<"can-"<0) + _params.ThresHold= float(newThres) ; + } + +#ifdef debug_lines + cv::imshow("image-lines",image); + cv::waitKey(10); +#endif + //now, move the points to the original image (upsample corners) + if (input.cols!=imgToBeThresHolded.cols){ + cornerUpsample(detectedMarkers,imgToBeThresHolded.size()); + Timer.add("Corner Upsample"); + } + + + + ////////////////////////////////////////////////////////////////////// + /// REMOVAL OF DUPLICATED + ////////////////////////////////////////////////////////////////////// + + // sort by id + std::sort(detectedMarkers.begin(), detectedMarkers.end()); + + // there might be still the case that a marker is detected twice because of the double border indicated earlier, + // detect and remove these cases + vector toRemove(detectedMarkers.size(), false); + + for (int i = 0; i < int(detectedMarkers.size()) - 1; i++) + { + for (int j = i + 1; j < int(detectedMarkers.size()) && !toRemove[i]; j++) + { + if (detectedMarkers[i].id == detectedMarkers[j].id && detectedMarkers[i].dict_info == detectedMarkers[j].dict_info) + { + // deletes the one with smaller perimeter + if (perimeter(detectedMarkers[i]) < perimeter(detectedMarkers[j])) + toRemove[i] = true; + else + toRemove[j] = true; + } + } + } + + removeElements(detectedMarkers,toRemove); + + + ////////////////////////////////////////////////////////////////////// + /// CORNER REFINEMENT IF REQUIRED + ////////////////////////////////////////////////////////////////////// + /// refine the corner location if enclosed markers and we did not do it via upsampling + if (detectedMarkers.size() > 0 && input.size()==imgToBeThresHolded.size() ){ + + if (_params.cornerRefinementM==CORNER_SUBPIX ){ + + int halfwsize= 4*float(input.cols)/float(imgToBeThresHolded.cols) +0.5 ; + + vector Corners; + for (unsigned int i = 0; i < detectedMarkers.size(); i++) + for (int c = 0; c < 4; c++) + Corners.push_back(detectedMarkers[i][c]); + cornerSubPix(grey, Corners, cvSize(halfwsize,halfwsize), cvSize(-1, -1),cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 12, 0.005)); + // copy back + for (unsigned int i = 0; i < detectedMarkers.size(); i++) + for (int c = 0; c < 4; c++) + detectedMarkers[i][c] = Corners[i * 4 + c]; + + } + else if ( _params.cornerRefinementM==CORNER_LINES){ + //use the lines method for estimation of the corners + for (unsigned int i = 0; i < detectedMarkers.size(); i++) + refineCornerWithContourLines(detectedMarkers[i]); + } + } +Timer.add("Corner Refinement"); + +// auto setPrecision=[](double f, double prec){ +// int x=roundf(f*prec); +// return double(x)/prec; +// }; + +// auto discretizeFloat=[](float v){ +// float f=v-float(int(v)); +// if (f<0.25) return float(int(v)); +// else if (f<0.75) return float(int(v))+0.5f; +// else return float(int(v+0.5f)); + +// }; + +//for(auto &dm:detectedMarkers){ +// for(auto &p:dm){ +//// p.x=setPrecision(p.x,10); +//// p.y=setPrecision(p.y,10); +// p.x=discretizeFloat(p.x); +// p.y=discretizeFloat(p.y); + +// } +//} + + ////////////////////////////////////////////////////////////////////// + /// MARKER POSE ESTIMATION + ////////////////////////////////////////////////////////////////////// + + /// detect the position of detected markers if desired + if (camMatrix.rows != 0 && markerSizeMeters > 0) + { + for (unsigned int i = 0; i < detectedMarkers.size(); i++) + detectedMarkers[i].calculateExtrinsics(markerSizeMeters, camMatrix, distCoeff, setYPerpendicular); + Timer.add("Pose Estimation"); + } + + //compute _markerMinSize + float mlength=std::numeric_limits::max(); + for(const auto &marker:detectedMarkers){ + float l=0; + for(int c=0;c<4;c++) + l+=cv::norm(marker[c]-marker[(c+1)%4]); + if (mlength>l)mlength=l; + } + float markerMinSize; + if (mlength!=std::numeric_limits::max() ) + markerMinSize=mlength/(4*std::max(input.cols,input.rows)); + else markerMinSize=0; + if (_params.autoSize){ + _params.minSize= markerMinSize*(1-_params.ts); + } + } +void MarkerDetector::refineCornerWithContourLines( aruco::Marker &marker,cv::Mat camMatrix,cv::Mat distCoeff ){ + // search corners on the contour vector + + std::vector &contour=marker.contourPoints; + vector< int > cornerIndex(4,-1); + vector dist(4,std::numeric_limits::max()); + for (unsigned int j = 0; j < contour.size(); j++) { + for (unsigned int k = 0; k < 4; k++) { + float d= (contour[j].x-marker[k].x)*(contour[j].x-marker[k].x) + + (contour[j].y-marker[k].y)*(contour[j].y-marker[k].y) ; + if (d cornerIndex[0]) && (cornerIndex[2] > cornerIndex[1] || cornerIndex[2] < cornerIndex[0])) + inverse = false; + else if (cornerIndex[2] > cornerIndex[1] && cornerIndex[2] < cornerIndex[0]) + inverse = false; + else + inverse = true; + + + // get pixel vector for each line of the marker + int inc = 1; + if (inverse) + inc = -1; + + // undistort contour + vector< Point2f > contour2f; + if(!camMatrix.empty() && !distCoeff.empty()){ + for (unsigned int i = 0; i < contour.size(); i++) + contour2f.push_back(cv::Point2f(contour[i].x, contour[i].y)); + if (!camMatrix.empty() && !distCoeff.empty()) + cv::undistortPoints(contour2f, contour2f, camMatrix, distCoeff, cv::Mat(), camMatrix); + + } + else { + contour2f.reserve(contour.size()); + for(auto p:contour) + contour2f.push_back(cv::Point2f(p.x,p.y)); + } + + vector< std::vector< cv::Point2f > > contourLines; + contourLines.resize(4); + for (unsigned int l = 0; l < 4; l++) { + for (int j = (int)cornerIndex[l]; j != (int)cornerIndex[(l + 1) % 4]; j += inc) { + if (j == (int)contour.size() && !inverse) + j = 0; + else if (j == 0 && inverse) + j = contour.size() - 1; + contourLines[l].push_back(contour2f[j]); + if (j == (int)cornerIndex[(l + 1) % 4]) + break; // this has to be added because of the previous ifs + } + } + + // interpolate marker lines + vector< Point3f > lines; + lines.resize(4); + for (unsigned int j = 0; j < lines.size(); j++) + interpolate2Dline(contourLines[j], lines[j]); + + // get cross points of lines + vector< Point2f > crossPoints; + crossPoints.resize(4); + for (unsigned int i = 0; i < 4; i++) + crossPoints[i] = getCrossPoint(lines[(i - 1) % 4], lines[i]); + + // distort corners again if undistortion was performed + if (!camMatrix.empty() && !distCoeff.empty()) + distortPoints(crossPoints, crossPoints, camMatrix, distCoeff); + + // reassing points + for (unsigned int j = 0; j < 4; j++){ + // cout<cand[endp].x){ + swap( startp,endp); + } + const float _180=3.14159f ; + + const float _22=3.14159/8.f; + const float _3_22=3.*3.14159f/8.f; + const float _5_22=5.f*3.14159f/8.f; + const float _7_22=7.f*3.14159f/8.f; + + int incx=0,incy=0; + //compute the angle + auto v1=cand[endp]-cand[startp]; + float angle=atan2( v1.y,v1.x); + if ( _22(_params.minSize)* static_cast(maxDim) ; + if (_params.minSize_pix!=-1) minSize=std::min(_params.minSize_pix, minSize ); + return minSize ; + +} +/************************************ + * + * + * + * + ************************************/ +bool MarkerDetector::warp(Mat& in, Mat& out, Size size, vector points) +{ + if (points.size() != 4) + throw cv::Exception(9001, "point.size()!=4", "MarkerDetector::warp", __FILE__, __LINE__); + // obtain the perspective transform + Point2f pointsRes[4], pointsIn[4]; + for (int i = 0; i < 4; i++) + pointsIn[i] = points[i]; + pointsRes[0] = (Point2f(0, 0)); + pointsRes[1] = Point2f(static_cast(size.width - 1), 0.f); + pointsRes[2] = Point2f(static_cast(size.width - 1), static_cast(size.height - 1)); + pointsRes[3] = Point2f(0.f, static_cast(size.height - 1)); + Mat M = getPerspectiveTransform(pointsIn, pointsRes); + cv::warpPerspective(in, out, M, size, cv::INTER_LINEAR); + // cv::warpPerspective(in, out, M, size, cv::INTER_NEAREST); + return true; +} + + +/************************************ + * + * + * + * + ************************************/ +int MarkerDetector::perimeter(const vector& a) +{ + int sum = 0; + for (unsigned int i = 0; i < a.size(); i++) + { + int i2 = (i + 1) % a.size(); + sum += static_cast( sqrt((a[i].x - a[i2].x) * (a[i].x - a[i2].x) + + (a[i].y - a[i2].y) * (a[i].y - a[i2].y))); + } + return sum; +} + + +/** + */ +void MarkerDetector::interpolate2Dline(const std::vector& inPoints, cv::Point3f& outLine) +{ + float minX, maxX, minY, maxY; + minX = maxX = inPoints[0].x; + minY = maxY = inPoints[0].y; + for (unsigned int i = 1; i < inPoints.size(); i++) + { + if (inPoints[i].x < minX) + minX = inPoints[i].x; + if (inPoints[i].x > maxX) + maxX = inPoints[i].x; + if (inPoints[i].y < minY) + minY = inPoints[i].y; + if (inPoints[i].y > maxY) + maxY = inPoints[i].y; + } + + // create matrices of equation system + const int pointsCount = static_cast(inPoints.size()); + Mat A(pointsCount, 2, CV_32FC1, Scalar(0)); + Mat B(pointsCount, 1, CV_32FC1, Scalar(0)); + Mat X; + + if (maxX - minX > maxY - minY) + { + // Ax + C = y + for (int i = 0; i < pointsCount; i++) + { + A.at(i, 0) = inPoints[i].x; + A.at(i, 1) = 1.; + B.at(i, 0) = inPoints[i].y; + } + + // solve system + solve(A, B, X, DECOMP_SVD); + // return Ax + By + C + outLine = Point3f(X.at(0, 0), -1., X.at(1, 0)); + } + else + { + // By + C = x + for (int i = 0; i < pointsCount; i++) + { + A.at(i, 0) = inPoints[i].y; + A.at(i, 1) = 1.; + B.at(i, 0) = inPoints[i].x; + } + + // solve system + solve(A, B, X, DECOMP_SVD); + // return Ax + By + C + outLine = Point3f(-1., X.at(0, 0), X.at(1, 0)); + } +} + +/** + */ +Point2f MarkerDetector::getCrossPoint(const cv::Point3f& line1, const cv::Point3f& line2) +{ + // create matrices of equation system + Mat A(2, 2, CV_32FC1, Scalar(0)); + Mat B(2, 1, CV_32FC1, Scalar(0)); + Mat X; + + A.at(0, 0) = line1.x; + A.at(0, 1) = line1.y; + B.at(0, 0) = -line1.z; + + A.at(1, 0) = line2.x; + A.at(1, 1) = line2.y; + B.at(1, 0) = -line2.z; + + // solve system + solve(A, B, X, DECOMP_SVD); + return Point2f(X.at(0, 0), X.at(1, 0)); +} + +void MarkerDetector::cornerUpsample(vector& MarkerCanditates, cv::Size lowResImageSize ){ + cornerUpsample_SUBP(MarkerCanditates,lowResImageSize); +} + +void MarkerDetector::cornerUpsample_SUBP(vector& MarkerCanditates, cv::Size lowResImageSize ){ + if (MarkerCanditates.size()==0)return; + //first, determine the image in the pyramid nearest to this one + int startPyrImg=0; + + for(size_t i=0;i=0;curpyr--){ + float factor= float(imagePyramid[curpyr].cols)/float(prevLowResSize.width) ; + //upsample corner locations + for(auto &m:MarkerCanditates) + for(auto &point:m) {point*=factor;} + int halfwsize= 0.5+2.5*factor; + vector p2d;p2d.reserve(MarkerCanditates.size()*4); + for(auto &m:MarkerCanditates) + for(auto &point:m) { p2d.push_back(point);} + cv::cornerSubPix( imagePyramid[curpyr],p2d,cv::Size(halfwsize,halfwsize),cv::Size(-1,-1),cvTermCriteria(CV_TERMCRIT_ITER , 4,0.5)); + int cidx=0; + for(auto &m:MarkerCanditates) + for(auto &point:m) {point =p2d[cidx++];} + + prevLowResSize=imagePyramid[curpyr].size(); + } + + +} + + +/************************************ + * + * + * + * + ************************************/ +void MarkerDetector::drawAllContours(Mat input, std::vector>& contours) +{ + drawContours(input, contours, -1, Scalar(255, 0, 255)); +} + +/************************************ + * + * + * + * + ************************************/ +void MarkerDetector::drawContour(Mat& in, vector& contour, Scalar color) +{ + for (unsigned int i = 0; i < contour.size(); i++) + { + cv::rectangle(in, contour[i], contour[i], color); + } +} + +void MarkerDetector::drawApproxCurve(Mat& in, vector& contour, Scalar color,int thickness) +{ + for (unsigned int i = 0; i < contour.size(); i++) + { + cv::line(in, contour[i], contour[(i + 1) % contour.size()], color,thickness); + } +} +/************************************ + * + * + * + * + ************************************/ + +void MarkerDetector::draw(Mat out, const vector& markers) +{ + for (unsigned int i = 0; i < markers.size(); i++) + { + cv::line(out, markers[i][0], markers[i][1], cvScalar(255, 0, 0), 2); + cv::line(out, markers[i][1], markers[i][2], cvScalar(255, 0, 0), 2); + cv::line(out, markers[i][2], markers[i][3], cvScalar(255, 0, 0), 2); + cv::line(out, markers[i][3], markers[i][0], cvScalar(255, 0, 0), 2); + } +} + + +void MarkerDetector::setMarkerLabeler(cv::Ptr detector) +{ + markerIdDetector = detector; +} + +void MarkerDetector::setDictionary(int dict_type, + float error_correction_rate) +{ + markerIdDetector = MarkerLabeler::create((Dictionary::DICT_TYPES)dict_type, error_correction_rate); + _params.error_correction_rate=error_correction_rate; + _params.dictionary=aruco::Dictionary::getTypeString((Dictionary::DICT_TYPES)dict_type); +} + + + + +void MarkerDetector::setDictionary(string dict_type, float error_correction_rate) +{ + auto _to_string=[](float i){ + std::stringstream str;str<=_thres_Images.size()) idx=_thres_Images.size()-1;//last one is the original image + return _thres_Images[idx]; +} + + + +/** + */ +void MarkerDetector::distortPoints(vector< cv::Point2f > in, vector< cv::Point2f > &out, const Mat &camMatrix, const Mat &distCoeff) { + // trivial extrinsics + cv::Mat Rvec = cv::Mat(3, 1, CV_32FC1, cv::Scalar::all(0)); + cv::Mat Tvec = Rvec.clone(); + // calculate 3d points and then reproject, so opencv makes the distortion internally + vector< cv::Point3f > cornersPoints3d; + for (unsigned int i = 0; i < in.size(); i++) + cornersPoints3d.push_back(cv::Point3f((in[i].x - camMatrix.at< float >(0, 2)) / camMatrix.at< float >(0, 0), // x + (in[i].y - camMatrix.at< float >(1, 2)) / camMatrix.at< float >(1, 1), // y + 1)); // z + cv::projectPoints(cornersPoints3d, Rvec, Tvec, camMatrix, distCoeff, out); +} + + +void MarkerDetector::Params::save(cv::FileStorage &fs)const{ + fs<<"aruco-dictionary"<>aux; + detectMode=getDetectionModeFromString(aux); + } + if ( fs["aruco-thresMethod"].type()!=cv::FileNode::NONE){ + string aux; + fs["aruco-thresMethod"]>>aux; + thresMethod=getCornerThresMethodFromString(aux); + } + if ( fs["aruco-cornerRefinementM"].type()!=cv::FileNode::NONE){ + string aux; + fs["aruco-cornerRefinementM"]>>aux; + cornerRefinementM=getCornerRefinementMethodFromString(aux); + } + + } + + +void MarkerDetector::Params::toStream(std::ostream &str)const{ + str.write((char*)&detectMode,sizeof(detectMode)); + str.write((char*)&maxThreads,sizeof(maxThreads)); + str.write((char*)&borderDistThres,sizeof(borderDistThres)); + str.write((char*)&lowResMarkerSize,sizeof(lowResMarkerSize)); + str.write((char*)&minSize,sizeof(minSize)); + str.write((char*)&minSize_pix,sizeof(minSize_pix)); + str.write((char*)&enclosedMarker,sizeof(enclosedMarker)); + str.write((char*)&thresMethod,sizeof(thresMethod)); + str.write((char*)&NAttemptsAutoThresFix,sizeof(NAttemptsAutoThresFix)); + str.write((char*)&AdaptiveThresWindowSize,sizeof(AdaptiveThresWindowSize)); + str.write((char*)&ThresHold,sizeof(ThresHold)); + str.write((char*)&AdaptiveThresWindowSize_range,sizeof(AdaptiveThresWindowSize_range)); + str.write((char*)&markerWarpPixSize,sizeof(markerWarpPixSize)); + str.write((char*)&cornerRefinementM,sizeof(cornerRefinementM)); + str.write((char*)&autoSize,sizeof(autoSize)); + str.write((char*)&ts,sizeof(pyrfactor)); + str.write((char*)&error_correction_rate,sizeof(error_correction_rate)); + _toStream(dictionary,str); +} +void MarkerDetector::Params::fromStream(std::istream &str) { + str.read((char*)&detectMode,sizeof(detectMode)); + str.read((char*)&maxThreads,sizeof(maxThreads)); + str.read((char*)&borderDistThres,sizeof(borderDistThres)); + str.read((char*)&lowResMarkerSize,sizeof(lowResMarkerSize)); + str.read((char*)&minSize,sizeof(minSize)); + str.read((char*)&minSize_pix,sizeof(minSize_pix)); + str.read((char*)&enclosedMarker,sizeof(enclosedMarker)); + str.read((char*)&thresMethod,sizeof(thresMethod)); + str.read((char*)&NAttemptsAutoThresFix,sizeof(NAttemptsAutoThresFix)); + str.read((char*)&AdaptiveThresWindowSize,sizeof(AdaptiveThresWindowSize)); + str.read((char*)&ThresHold,sizeof(ThresHold)); + str.read((char*)&AdaptiveThresWindowSize_range,sizeof(AdaptiveThresWindowSize_range)); + str.read((char*)&markerWarpPixSize,sizeof(markerWarpPixSize)); + str.read((char*)&cornerRefinementM,sizeof(cornerRefinementM)); + str.read((char*)&autoSize,sizeof(autoSize)); + str.read((char*)&ts,sizeof(pyrfactor)); + str.read((char*)&error_correction_rate,sizeof(error_correction_rate)); + _fromStream(dictionary,str); +} +/**Saves the configuration of the detector to a file + */ +void MarkerDetector::saveParamsToFile(const std::string &path) const{ + + cv::FileStorage fs(path, cv::FileStorage::WRITE); + if(!fs.isOpened())throw std::runtime_error("Could not open "+path); + _params.save(fs); +} + +/**Loads the configuration from a file + */ +void MarkerDetector::loadParamsFromFile(const std::string &path){ + cv::FileStorage fs(path, cv::FileStorage::READ); + if(!fs.isOpened())throw std::runtime_error("Could not open "+path); + _params.load(fs); + setDictionary(_params.dictionary,_params.error_correction_rate); +} + +void MarkerDetector::toStream(std::ostream &str)const +{ + uint64_t sig=13213; + str.write((char*)&sig,sizeof(sig)); + _params.toStream(str); +} + +void MarkerDetector::fromStream(std::istream &str){ + uint64_t sig=13213; + str.read((char*)&sig,sizeof(sig)); + if (sig!=13213) throw std::runtime_error("MarkerDetector::fromStream invalid signature"); + _params.fromStream(str); + setDictionary(_params.dictionary,_params.error_correction_rate); + +} + +std::string MarkerDetector::Params::toString(DetectionMode dm){ + switch(dm){ + case DM_FAST:return "DM_FAST"; + case DM_NORMAL:return "DM_NORMAL"; + case DM_VIDEO_FAST:return "DM_VIDEO_FAST"; + }; + return "DM_NORMAL"; +} + +DetectionMode MarkerDetector::Params::getDetectionModeFromString(const std::string &str){ + if ( str=="DM_FAST")return DM_FAST; + if ( str=="DM_NORMAL")return DM_NORMAL; + if ( str=="DM_VIDEO_FAST")return DM_VIDEO_FAST; + return DM_NORMAL; + +} + +std::string MarkerDetector::Params::toString(CornerRefinementMethod dm){ + switch(dm){ + case CORNER_LINES:return "CORNER_LINES"; + case CORNER_SUBPIX:return "CORNER_SUBPIX"; + case CORNER_NONE:return "CORNER_NONE"; + }; + return "CORNER_SUBPIX"; +} +CornerRefinementMethod MarkerDetector::Params::getCornerRefinementMethodFromString(const std::string &str){ + if ( str=="CORNER_LINES")return CORNER_LINES; + if ( str=="CORNER_SUBPIX")return CORNER_SUBPIX; + if ( str=="CORNER_NONE")return CORNER_NONE; + return CORNER_SUBPIX; +} +std::string MarkerDetector::Params::toString(MarkerDetector::ThresMethod dm){ + switch(dm){ + case THRES_ADAPTIVE:return "THRES_ADAPTIVE"; + case THRES_AUTO_FIXED:return "THRES_AUTO_FIXED"; + }; + return "THRES_ADAPTIVE"; +} +MarkerDetector::ThresMethod MarkerDetector::Params::getCornerThresMethodFromString(const std::string &str){ + if ( str=="THRES_ADAPTIVE")return THRES_ADAPTIVE; + if ( str=="THRES_AUTO_FIXED")return THRES_AUTO_FIXED; + return THRES_ADAPTIVE; +} +void MarkerDetector::Params::setThresholdMethod( MarkerDetector::ThresMethod method,int thresHold,int wsize,int wsize_range ){ + AdaptiveThresWindowSize=wsize; + thresMethod=method; + if (thresHold==-1){ + if ( method==THRES_AUTO_FIXED ) ThresHold=100; + else ThresHold=7; + } + else ThresHold=thresHold; + AdaptiveThresWindowSize_range=wsize_range; +} +void MarkerDetector::Params::setDetectionMode( DetectionMode dm,float minMarkerSize){ + detectMode=dm; + minSize=minMarkerSize; + if(detectMode==DM_NORMAL){ + setAutoSizeSpeedUp(false); + setThresholdMethod(THRES_ADAPTIVE); + } + else if (detectMode==DM_FAST ){ + setAutoSizeSpeedUp(false); + setThresholdMethod(THRES_AUTO_FIXED); + } + else if(detectMode==DM_VIDEO_FAST){ + setThresholdMethod(THRES_AUTO_FIXED); + setAutoSizeSpeedUp(true,0.3); + } +} +void MarkerDetector::Params::setCornerRefinementMethod( CornerRefinementMethod method){ + cornerRefinementM=method; + if(method!=CORNER_SUBPIX) minSize=0; +} + +}; diff --git a/src/include/aruco/markerdetector.h b/src/aruco/markerdetector.h similarity index 59% rename from src/include/aruco/markerdetector.h rename to src/aruco/markerdetector.h index a5af3fd..e896be1 100644 --- a/src/include/aruco/markerdetector.h +++ b/src/aruco/markerdetector.h @@ -31,7 +31,7 @@ or implied, of Rafael Muñoz Salinas. #define _ARUCO_MarkerDetector_H #include "aruco_export.h" -#include +#include #include #include #include @@ -42,109 +42,156 @@ or implied, of Rafael Muñoz Salinas. namespace aruco { - /** - * @brief The DetectionMode enum defines the different possibilities for detection + +/** + * @brief The DetectionMode enum defines the different possibilities for detection. + * Specifies the detection mode. We have preset three types of detection modes. These are + * ways to configure the internal parameters for the most typical situations. The modes are: + * - DM_NORMAL: In this mode, the full resolution image is employed for detection and slow threshold method. Use this method when + * you process individual images that are not part of a video sequence and you are not interested in speed. + * + * - DM_FAST: In this mode, there are two main improvements. First, image is threshold using a faster method using a global threshold. + * Also, the full resolution image is employed for detection, but, you could speed up detection even more by indicating a minimum size of the + * markers you will accept. This is set by the variable minMarkerSize which shoud be in range [0,1]. When it is 0, means that you do not set + * a limit in the size of the accepted markers. However, if you set 0.1, it means that markers smaller than 10% of the total image area, will not + * be detected. Then, the detection can be accelated up to orders of magnitude compared to the normal mode. + * + * - DM_VIDEO_FAST: This is similar to DM_FAST, but specially adapted to video processing. In that case, we assume that the observed markers + * when you call to detect() have a size similar to the ones observed in the previous frame. Then, the processing can be speeded up by employing smaller versions + * of the image automatically calculated. * */ - enum DetectionMode: int{DM_NORMAL=0,DM_FAST=1,DM_VIDEO_FAST=2}; - enum ThresMethod: int{THRES_ADAPTIVE=0,THRES_AUTO_FIXED=1 }; +enum DetectionMode: int{DM_NORMAL=0,DM_FAST=1,DM_VIDEO_FAST=2}; +/** Method employed to refine the estimation of the corners +* - CORNER_SUBPIX: uses subpixel refinement implemented in opencv +* - CORNER_LINES: uses all the pixels in the corner border to estimate the 4 lines of the square. Then +* estimate the point in which they intersect. In seems that it more robust to noise. However, it only works if input image is not resized. +* So, the value minMarkerSize will be set to 0. +* +* - CORNER_NONE: Does no refinement of the corner. Again, it requires minMakerSize to be 0 +*/ +enum CornerRefinementMethod: int{CORNER_SUBPIX=0,CORNER_LINES=1,CORNER_NONE=2}; - /**Operating params - */ - struct Params - { - //maximum number of parallel threads - int maxThreads=1;//-1 means all - - // border around image limits in which corners are not allowed to be detected. (0,1) - float borderDistThres=0.015f; - int lowResMarkerSize=20; //minimum size of a marker in the low resolution image - - // minimum size of a contour lenght. We use the following formula - // minLenght= min ( _minSize_pix , _minSize* Is)*4 - // being Is=max(imageWidth,imageHeight) - // the value _minSize are normalized, thus, depends on camera image size - // However, _minSize_pix is expressed in pixels (you can use the one you prefer) - float minSize=-1;//tau_i in paper - int minSize_pix=-1; - bool enclosedMarker=false;//special treatment for enclosed markers - - - void setThresholdMethod(ThresMethod method,int thresHold=-1,int wsize=15,int wsize_range=0 ){ - _AdaptiveThresWindowSize=wsize; - _thresMethod=method; - if (thresHold==-1){ - if ( method==THRES_AUTO_FIXED ) _ThresHold=100; - else _ThresHold=10; - } - else _ThresHold=thresHold; - _AdaptiveThresWindowSize_range=wsize_range; - } +class CameraParameters; +class MarkerLabeler; +/**\brief Main class for marker detection + * + */ +class ARUCO_EXPORT MarkerDetector +{ + enum ThresMethod: int{THRES_ADAPTIVE=0,THRES_AUTO_FIXED=1 }; +public: - //threshold methods - ThresMethod _thresMethod=THRES_ADAPTIVE; - int NAttemptsAutoThresFix=3;//number of times that tries a random threshold in case of THRES_AUTO_FIXED + /**Operating params + */ + struct ARUCO_EXPORT Params + { + /**Specifies the detection mode. We have preset three types of detection modes. These are + * ways to configure the internal parameters for the most typical situations. The modes are: + * - DM_NORMAL: In this mode, the full resolution image is employed for detection and slow threshold method. Use this method when + * you process individual images that are not part of a video sequence and you are not interested in speed. + * + * - DM_FAST: In this mode, there are two main improvements. First, image is threshold using a faster method using a global threshold. + * Also, the full resolution image is employed for detection, but, you could speed up detection even more by indicating a minimum size of the + * markers you will accept. This is set by the variable minMarkerSize which shoud be in range [0,1]. When it is 0, means that you do not set + * a limit in the size of the accepted markers. However, if you set 0.1, it means that markers smaller than 10% of the total image area, will not + * be detected. Then, the detection can be accelated up to orders of magnitude compared to the normal mode. + * + * - DM_VIDEO_FAST: This is similar to DM_FAST, but specially adapted to video processing. In that case, we assume that the observed markers + * when you call to detect() have a size similar to the ones observed in the previous frame. Then, the processing can be speeded up by employing smaller versions + * of the image automatically calculated. + * + */ + void setDetectionMode( DetectionMode dm,float minMarkerSize); + + /**Enables/Disbles the detection of enclosed markers. Enclosed markers are markers where corners are like opencv chessboard pattern + */ + void detectEnclosedMarkers(bool do_){enclosedMarker=do_;} + + /**Sets the corner refinement method + * - CORNER_SUBPIX: uses subpixel refinement implemented in opencv + * - CORNER_LINES: uses all the pixels in the corner border to estimate the 4 lines of the square. Then + * estimate the point in which they intersect. In seems that it more robust to noise. However, it only works if input image is not resized. + * So, the value minMarkerSize will be set to 0. + * + * - CORNER_NONE: Does no refinement of the corner. Again, it requires minMakerSize to be 0 + */ + void setCornerRefinementMethod( CornerRefinementMethod method); - // Threshold parameters - int _AdaptiveThresWindowSize=15, _ThresHold=10, _AdaptiveThresWindowSize_range=0; - // size of the image passedta to the MarkerLabeler - int _markerWarpPixSize=5;//tau_c in paper - // - //enable/disables the method for automatic size estimation for speed up - bool _autoSize=false; - float _ts=0.25f;//$\tau_s$ is a factor in the range $(0,1]$ that accounts for the camera motion speed. For instance, when $\tau_s=0.1$, it means that in the next frame, $\tau_i$ is such that markers $10\%$ smaller than the smallest marker in the current image will be seek. To avoid loosing track of the markers. If no markers are detected in a frame, $\tau_i$ is set to zero for the next frame so that markers of any size can be detected. - /**Enables automatic image resize according to elements detected in previous frame - * @param v - * @param ts is a factor in the range $(0,1]$ that accounts for the camera motion speed. For instance, when ts=0.1 , it means that in the next frame, $\tau_i$ is such that markers $10\%$ smaller than the smallest marker in the current image will be seek. To avoid loosing track of the markers. + //----------------------------------------------------------------------------- + // Below this point you probably should not use the functions + /**Sets the thresholding method manually. Do no */ - void setAutoSizeSpeedUp(bool v,float ts=0.25){_autoSize=v;_ts=ts;} - bool getAutoSizeSpeedUp()const{return _autoSize;} + void setThresholdMethod(ThresMethod method,int thresHold=-1,int wsize=-1,int wsize_range=0 ); - float pyrfactor=2; - }; - // Represent a candidate to be a maker - class MarkerCandidate : public Marker - { - public: - MarkerCandidate() - { - } - MarkerCandidate(const Marker& M) - : Marker(M) - { - } - MarkerCandidate(const MarkerCandidate& M) - : Marker(M) - { - contour = M.contour; - idx = M.idx; - } - MarkerCandidate& operator=(const MarkerCandidate& M) - { - (*(Marker*)this) = (*(Marker*)&M); - contour = M.contour; - idx = M.idx; - return *this; - } + void setAutoSizeSpeedUp(bool v,float Ts=0.25){autoSize=v;ts=Ts;} + bool getAutoSizeSpeedUp()const{return autoSize;} - vector contour; // all the points of its contour - int idx; // index position in the global contour list - }; - class CameraParameters; - class MarkerLabeler; - /**\brief Main class for marker detection - * - */ - class ARUCO_EXPORT MarkerDetector - { - public: + + + void save(cv::FileStorage &fs)const; + void load(cv::FileStorage &fs); + + void toStream(std::ostream &str)const; + void fromStream(std::istream &str); + + static std::string toString(DetectionMode dm); + static DetectionMode getDetectionModeFromString(const std::string &str); + static std::string toString(CornerRefinementMethod dm); + static CornerRefinementMethod getCornerRefinementMethodFromString(const std::string &str); + static std::string toString(ThresMethod dm); + static ThresMethod getCornerThresMethodFromString(const std::string &str); + + //Detection mode + + DetectionMode detectMode=DM_NORMAL; + + //maximum number of parallel threads + int maxThreads=1;//-1 means all + + // border around image limits in which corners are not allowed to be detected. (0,1) + float borderDistThres=0.015f; + int lowResMarkerSize=20; //minimum size of a marker in the low resolution image + + // minimum size of a contour lenght. We use the following formula + // minLenght= min ( _minSize_pix , _minSize* Is)*4 + // being Is=max(imageWidth,imageHeight) + // the value _minSize are normalized, thus, depends on camera image size + // However, _minSize_pix is expressed in pixels (you can use the one you prefer) + float minSize=-1;//tau_i in paper + int minSize_pix=-1; + bool enclosedMarker=false;//special treatment for enclosed markers + float error_correction_rate=0; + std::string dictionary="ALL_DICTS"; + //threshold methods + ThresMethod thresMethod=THRES_ADAPTIVE; + int NAttemptsAutoThresFix=3;//number of times that tries a random threshold in case of THRES_AUTO_FIXED + + + // Threshold parameters + int AdaptiveThresWindowSize=-1, ThresHold=7, AdaptiveThresWindowSize_range=0; + // size of the image passedta to the MarkerLabeler + int markerWarpPixSize=5;//tau_c in paper + + CornerRefinementMethod cornerRefinementM=CORNER_SUBPIX; + //enable/disables the method for automatic size estimation for speed up + bool autoSize=false; + float ts=0.25f;//$\tau_s$ is a factor in the range $(0,1]$ that accounts for the camera motion speed. For instance, when $\tau_s=0.1$, it means that in the next frame, $\tau_i$ is such that markers $10\%$ smaller than the smallest marker in the current image will be seek. To avoid loosing track of the markers. If no markers are detected in a frame, $\tau_i$ is set to zero for the next frame so that markers of any size can be detected. + /**Enables automatic image resize according to elements detected in previous frame + * @param v + * @param ts is a factor in the range $(0,1]$ that accounts for the camera motion speed. For instance, when ts=0.1 , it means that in the next frame, $\tau_i$ is such that markers $10\%$ smaller than the smallest marker in the current image will be seek. To avoid loosing track of the markers. + */ + float pyrfactor=2; + + }; + /** * See */ @@ -159,6 +206,15 @@ namespace aruco MarkerDetector(int dict_type, float error_correction_rate = 0); MarkerDetector(std::string dict_type, float error_correction_rate = 0); + /**Saves the configuration of the detector to a file. + */ + void saveParamsToFile(const std::string &path)const; + + /**Loads the configuration from a file. + */ + void loadParamsFromFile(const std::string &path); + + /** */ ~MarkerDetector(); @@ -182,7 +238,7 @@ namespace aruco /**returns current detection mode */ DetectionMode getDetectionMode( ); - /**Detects the markers in the image passed + /**Detects the markers in the image passed * * If you provide information about the camera parameters and the size of the marker, then, the extrinsics of * the markers are detected @@ -234,14 +290,12 @@ namespace aruco cv::Mat distCoeff = cv::Mat(), float markerSizeMeters = -1, bool setYPerperdicular = false); -// /**Sets operating params -// */ -// void setParams(Params p); -// /**Returns operating params -// */ + + /**Returns operating params + */ Params getParameters() const{return _params;} -// /**Returns operating params -// */ + /**Returns operating params + */ Params & getParameters() {return _params;} /** Sets the dictionary to be employed. * You can choose:ARUCO,//original aruco dictionary. By default @@ -276,6 +330,9 @@ namespace aruco * Returns a reference to the internal image thresholded. Since there can be generated many of them, specify which */ cv::Mat getThresholdedImage(uint32_t idx=0); + /**returns the number of thresholed images available + */ + size_t getNhresholdedImages()const{return _thres_Images.size();} @@ -293,11 +350,35 @@ namespace aruco { return markerIdDetector; } - /** - * Detection of candidates to be markers, i.e., rectangles. - * This function returns in candidates all the rectangles found in a thresolded image - */ -// void detectRectangles(const ThresImage &thresImg, vector>& candidates); + // Represent a candidate to be a maker + class MarkerCandidate : public Marker + { + public: + MarkerCandidate() + { + } + MarkerCandidate(const Marker& M) + : Marker(M) + { + } + MarkerCandidate(const MarkerCandidate& M) + : Marker(M) + { + contour = M.contour; + idx = M.idx; + } + MarkerCandidate& operator=(const MarkerCandidate& M) + { + (*(Marker*)this) = (*(Marker*)&M); + contour = M.contour; + idx = M.idx; + return *this; + } + + vector contour; // all the points of its contour + int idx; // index position in the global contour list + }; + /**Returns a list candidates to be markers (rectangles), for which no valid id was found after calling * detectRectangles @@ -318,13 +399,18 @@ namespace aruco bool warp(cv::Mat& in, cv::Mat& out, cv::Size size, std::vector points); + //serialization in binary mode + void toStream(std::ostream &str)const; + void fromStream(std::istream &str); + //configure the detector from a set of parameters + void setParameters(const Params ¶ms); private: // operating params Params _params; - DetectionMode _detectMode=DM_NORMAL; + // Images cv::Mat grey, thres; // pointer to the function that analizes a rectangular region so as to detect its internal marker @@ -389,9 +475,9 @@ namespace aruco - std::vector< aruco::MarkerCandidate > thresholdAndDetectRectangles(const cv::Mat & input, int thres_param1, int thres_param2,bool erode,cv::Mat &auxThresImage); - std::vector< aruco::MarkerCandidate > thresholdAndDetectRectangles(const cv::Mat &image); - std::vector< aruco::MarkerCandidate > prefilterCandidates( std::vector< MarkerCandidate> &candidates,cv::Size orgImageSize); + std::vector thresholdAndDetectRectangles(const cv::Mat & input, int thres_param1, int thres_param2,bool erode,cv::Mat &auxThresImage); + std::vector thresholdAndDetectRectangles(const cv::Mat &image); + std::vector< aruco::MarkerDetector::MarkerCandidate> prefilterCandidates( std::vector< MarkerCandidate> &candidates,cv::Size orgImageSize); std::vector _thres_Images; @@ -406,7 +492,7 @@ namespace aruco - enum ThreadTasks {THRESHOLD_TASK,ERODE_TASK,EXIT_TASK}; + enum ThreadTasks {THRESHOLD_TASK,ENCLOSE_TASK,EXIT_TASK}; struct ThresAndDetectRectTASK{ int inIdx,outIdx; int param1,param2; @@ -452,6 +538,36 @@ namespace aruco std::condition_variable cond_; }; Queue _tasks; + void refineCornerWithContourLines( aruco::Marker &marker,cv::Mat cameraMatrix=cv::Mat(),cv::Mat distCoef=cv::Mat()); + + inline float pointSqdist(cv::Point &p,cv::Point2f&p2){ + float dx=p.x-p2.x; + float dy=p.y-p2.y; + return dx*dx+dy*dy; + } + + float _tooNearDistance=-1;//pixel distance between nearr rectangle. Computed automatically based on the params + private: + template + static bool attemtpRead(const std::string &name,Type &var,cv::FileStorage&fs ){ + if ( fs[name].type()!=cv::FileNode::NONE){ + fs[name]>>var; + return true; + } + return false; + } + + static void _toStream(const std::string &strg,std::ostream &str){ + uint32_t s=strg.size(); + str.write((char*)&s,sizeof(s)); + str.write(strg.c_str(),strg.size()); + } + static void _fromStream(std::string &strg,std::istream &str){ + uint32_t s; + str.read((char*)&s,sizeof(s)); + strg.resize(s); + str.read(&strg[0],strg.size()); + } }; }; diff --git a/src/aruco/markerlabeler.cpp b/src/aruco/markerlabeler.cpp new file mode 100644 index 0000000..f48b145 --- /dev/null +++ b/src/aruco/markerlabeler.cpp @@ -0,0 +1,77 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "markerlabeler.h" +#ifdef USE_SVM_LABELER +#include "markerlabelers/svmmarkers.h" +#endif +#include "markerlabelers/dictionary_based.h" + namespace aruco +{ + cv::Ptr MarkerLabeler::create(Dictionary::DICT_TYPES dict_type, + float error_correction_rate) + { + Dictionary dict = Dictionary::loadPredefined(dict_type); + DictionaryBased* db = new DictionaryBased(); + db->setParams(dict, error_correction_rate); + return db; + } + + cv::Ptr MarkerLabeler::create(std::string detector, std::string params) + { + auto _stof=[](std::string str){ + float f;sscanf(str.c_str(),"%f",&f);return f; + }; + (void)params; + if (detector == "SVM") + { +#ifdef USE_SVM_LABELER + + SVMMarkers* svm = new SVMMarkers; + if (!svm->load(params)) + throw cv::Exception(-1, "Could not open svm file :" + params, "Detector::create", " ", -1); + //*SVMmodel,dictsize, -1, 1, true); + return svm; +#else + throw cv::Exception(-1, "SVM labeler not compiled", "Detector::create", " ", -1); +#endif + } + else + { + + + Dictionary dict = Dictionary::load(detector); + // try with one from file + DictionaryBased* db = new DictionaryBased(); + db->setParams(dict, _stof(params)); + return db; + } + + throw cv::Exception(-1, "No valid labeler indicated:" + detector, "Detector::create", " ", -1); + } +} diff --git a/src/include/aruco/markerlabeler.h b/src/aruco/markerlabeler.h similarity index 99% rename from src/include/aruco/markerlabeler.h rename to src/aruco/markerlabeler.h index bd370ba..79c4224 100644 --- a/src/include/aruco/markerlabeler.h +++ b/src/aruco/markerlabeler.h @@ -31,7 +31,7 @@ or implied, of Rafael Muñoz Salinas. #include "aruco_export.h" #include "dictionary.h" -#include +#include namespace aruco { diff --git a/src/aruco/markerlabelers/dictionary_based.cpp b/src/aruco/markerlabelers/dictionary_based.cpp new file mode 100644 index 0000000..9a4bca3 --- /dev/null +++ b/src/aruco/markerlabelers/dictionary_based.cpp @@ -0,0 +1,290 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "dictionary_based.h" + +#include + +#include +#include + +namespace aruco +{ + void DictionaryBased::setParams(const Dictionary& dic, float max_correction_rate) + { + + _nsubdivisions=sqrt(dic.nbits())+2; + nbits_dict.clear(); + dicttypename=dic.getName(); + if (dic.getType()==Dictionary::ALL_DICTS){ + for(auto &dt:Dictionary::getDicTypes()) + if (dt!="ALL_DICTS" && dt!="CUSTOM") + vdic.push_back( Dictionary ::loadPredefined(dt)); + } + else vdic.push_back( dic); + + // + for(auto &dic:vdic) + nbits_dict[dic.nbits()].push_back(&dic); + + _max_correction_rate = std::max(0.f, std::min(1.0f, max_correction_rate)); + } + + std::string DictionaryBased::getName() const + { + return dicttypename; + } + + void DictionaryBased::toMat(uint64_t code, int nbits_sq, cv::Mat& out) + { + out.create(nbits_sq, nbits_sq, CV_8UC1); + std::bitset<64> bs(code); + int curbit = 0; + for (int r = 0; r < nbits_sq; r++) + { + uchar* pr = out.ptr(r); + for (int c = 0; c < nbits_sq; c++) + pr[c] = bs[curbit]; + } + } + + int hamm_distance(uint64_t a, uint64_t b) + { + return static_cast(std::bitset<64>(a ^ b).count()); + } + + bool DictionaryBased::detect(const cv::Mat& in, int& marker_id, int& nRotations, std::string &additionalInfo) + { + assert(in.rows == in.cols); + + cv::Mat grey; + if (in.type() == CV_8UC1) grey = in; + else cv::cvtColor(in, grey, CV_BGR2GRAY); + // threshold image + cv::threshold(grey, grey, 125, 255, cv::THRESH_BINARY | cv::THRESH_OTSU); + + std::map > nbits_ids; + //for each + for(auto &bitsids:nbits_dict){ + int nbits=bitsids.first; + std::vector ids; + getInnerCode(grey,nbits,ids); + if (ids.size()>0){ + if (ids[0]!=0){ + nbits_ids[nbits]=ids; + } + } + } + //how many are there? + + if ( nbits_ids.size()==0)return false; + //check if any dictionary recognizes it + for(auto nbits:nbits_ids){ + const auto &ids=nbits.second; + //check in every dictionary + for(auto &dic:nbits_dict[nbits.first]){ + //try a perfecf match + for(int rot=0;rot<4;rot++) + if ( dic->is( ids[rot])){ + // std::cout<<"MATCH:"<getName()<<" "<at (ids[rot]); + additionalInfo=dic->getName(); + return true; + } + + //try with some error/correction if allowed + if (_max_correction_rate > 0) + { // find distance to map elements + int _maxCorrectionAllowed = static_cast( static_cast(dic->tau()) * _max_correction_rate); + for (auto ci : dic->getMapCode()) + { + for (int i = 0; i < 4; i++) + { + if (hamm_distance(ci.first, ids[i]) < _maxCorrectionAllowed) + { + marker_id = ci.second; + nRotations = i; + additionalInfo=dic->getName(); + return true; + } + } + } + } + + } + + + } + + + return false; + } + + + bool DictionaryBased::getInnerCode(const cv::Mat& thres_img, int total_nbits, std::vector& ids) + { + int bits_noborder = static_cast(std::sqrt(total_nbits)); + int bits_withborder = bits_noborder + 2; + // Markers are divided in (bits_a+2)x(bits_a+2) regions, of which the inner bits_axbits_a belongs to marker + // info + // the external border shoould be entirely black + cv::Mat nonZeros(bits_withborder,bits_withborder,CV_32SC1); + cv::Mat nValues(bits_withborder,bits_withborder,CV_32SC1); + nonZeros.setTo(cv::Scalar::all(0)); + nValues.setTo(cv::Scalar::all(0)); + for (int y = 0; y < thres_img.rows; y++) + { + const uchar *ptr=thres_img.ptr(y); + int my= float(bits_withborder)*float(y)/ float(thres_img.rows); + for (int x = 0; x < thres_img.cols; x++) + { + int mx= float(bits_withborder)*float(x)/ float(thres_img.cols); + if( ptr[x]>125) + nonZeros.at(my,mx)++; + nValues.at(my,mx)++; + } + } + cv::Mat binaryCode(bits_withborder,bits_withborder,CV_8UC1); + //now, make the theshold + for(int y=0;y(y,x)>nValues.at(y,x)/2) + binaryCode.at(y,x)=1; + else + binaryCode.at(y,x)=0; + } + + //check if border is completely black + for (int y = 0; y < bits_withborder; y++) + { + int inc = bits_withborder - 1; + if (y == 0 || y == bits_withborder - 1) + inc = 1; // for first and last row, check the whole border + for (int x = 0; x < bits_withborder; x += inc) + if (binaryCode.at(y,x)!=0 ) return false; + } + + //take the inner code + + cv::Mat _bits(bits_noborder,bits_noborder,CV_8UC1); + for(int y=0;y(y,x)=binaryCode.at(y+1,x+1); + + // now, get the 64bits ids + + int nr = 0; + do + { + ids.push_back(touulong(_bits)); + _bits = rotate(_bits); + nr++; + } while (nr < 4); + return true; + } + + +// bool DictionaryBased::getInnerCode(const cv::Mat& thres_img, int total_nbits, std::vector& ids) +// { +// auto toInt=[](float v){return int(v+0.5);}; +// int bits_a = static_cast(std::sqrt(total_nbits)); +// int bits_a2 = bits_a + 2; +// // Markers are divided in (bits_a+2)x(bits_a+2) regions, of which the inner bits_axbits_a belongs to marker +// // info +// // the external border shoould be entirely black + +// float swidth = float(thres_img.rows) / float(bits_a2); +// for (int y = 0; y < bits_a2; y++) +// { +// int inc = bits_a2 - 1; +// if (y == 0 || y == bits_a2 - 1) +// inc = 1; // for first and last row, check the whole border +// for (int x = 0; x < bits_a2; x += inc) +// { +// cv::Mat square = thres_img(cv::Rect( toInt(float(x) * swidth ), toInt(float(y) * swidth), swidth, swidth)); +// if (cv::countNonZero(square) > (swidth * swidth) / 2) +// return false; // can not be a marker because the border element is not black! +// } +// } + +// // now, +// // get information(for each inner square, determine if it is black or white) + +// // now, +// cv::Mat _bits = cv::Mat::zeros(bits_a, bits_a, CV_8UC1); +// // get information(for each inner square, determine if it is black or white) + +// for (int y = 0; y < bits_a; y++) +// { +// for (int x = 0; x < bits_a; x++) +// { +// int Xstart = toInt(float(x + 1) * swidth); +// int Ystart = toInt(float(y + 1) * swidth); +// cv::Mat square = thres_img(cv::Rect(Xstart, Ystart, swidth, swidth)); +// int nZ = cv::countNonZero(square); +// if (nZ > (swidth * swidth) / 2) +// _bits.at(y, x) = 1; +// } +// } +// // now, get the 64bits ids + +// int nr = 0; +// do +// { +// ids.push_back(touulong(_bits)); +// _bits = rotate(_bits); +// nr++; +// } while (nr < 4); +// return true; +// } + + // convert matrix of (0,1)s in a 64 bit value + uint64_t DictionaryBased::touulong(const cv::Mat& code) + { + std::bitset<64> bits; + int bidx = 0; + for (int y = code.rows - 1; y >= 0; y--) + for (int x = code.cols - 1; x >= 0; x--) + bits[bidx++] = code.at(y, x); + return bits.to_ullong(); + } + cv::Mat DictionaryBased::rotate(const cv::Mat& in) + { + cv::Mat out; + in.copyTo(out); + for (int i = 0; i < in.rows; i++) + { + for (int j = 0; j < in.cols; j++) + { + out.at(i, j) = in.at(in.cols - j - 1, i); + } + } + return out; + } +} diff --git a/src/include/aruco/markerlabelers/dictionary_based.h b/src/aruco/markerlabelers/dictionary_based.h similarity index 100% rename from src/include/aruco/markerlabelers/dictionary_based.h rename to src/aruco/markerlabelers/dictionary_based.h diff --git a/src/aruco/markerlabelers/svmmarkers.cpp b/src/aruco/markerlabelers/svmmarkers.cpp new file mode 100755 index 0000000..a00563c --- /dev/null +++ b/src/aruco/markerlabelers/svmmarkers.cpp @@ -0,0 +1,179 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "svmmarkers.h" +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +using namespace std; + +namespace aruco { +namespace impl{ +class SVMMarkers { + float _minFeatureValue, _maxFeatureValue; // image range for svm classification + int _patchSize, _dictSize; // marker pathSize (total features = pathSize^2) and dictionary size (number of markers) + bool _rotateMarkers; // interchange rotation 1 and 3 ?? +#if CV_MAJOR_VERSION >= 3 + cv::Ptr _model; +#else + cv::Ptr _model ; +#endif +public: + SVMMarkers(){ + // static variables from SVMMarkers. Need to be here to avoid linking errors + _minFeatureValue = -1; + _maxFeatureValue = 1; + _patchSize = 10; + _dictSize = -1; + _rotateMarkers = true; + + } + + + int getBestInputSize(){return _patchSize;} + bool load(string path) { + if (path.empty())return false; + + +#if CV_MAJOR_VERSION >= 3 + _model= cv::ml::StatModel::load(path); + _patchSize=sqrt(_model->getSupportVectors().size().width); + +#else + _model=new CvSVM; + _model->load(path.c_str()); + _patchSize=sqrt(_model->get_var_count()); + +#endif + //read in the file the number of classes + ifstream svmfile(path.c_str()); + if (!svmfile)return false; + _dictSize=-1; + while(!svmfile.eof()){ + std::string str; + std::getline(svmfile,str); + if (str.find("class_count:")!=std::string::npos){ + stringstream sstr;sstr<>cc>>nclasses; + _dictSize=(nclasses-1)/4; + } + } + if (_dictSize==-1)return false; + + return true; + } + + + + + + + /** + */ + bool detect(const cv::Mat &in, int &mid,int &nRotations) { + + + // convert to gray + assert(in.rows == in.cols); + cv::Mat grey; + if (in.type() == CV_8UC1) + grey = in; + else + cv::cvtColor(in, grey, CV_BGR2GRAY); + + // resize to svm path size + cv::Mat greyResized; + if(grey.cols != _patchSize) + cv::resize(grey, greyResized, cv::Size(_patchSize, _patchSize) ); + else + greyResized = grey; + + // normalize image range + cv::Mat greyResizedNormalized; + cv::normalize(greyResized, greyResizedNormalized, _minFeatureValue, _maxFeatureValue, cv::NORM_MINMAX, CV_32FC1); + + // rearrange data in a row + cv::Mat dataRow; + dataRow = greyResizedNormalized.reshape(1,1); + + // predict id with svm +#if CV_VERSION_MAJOR >= 3 + int predict_id = (int)_model->predict(dataRow); +#else + int predict_id = (int)_model->predict(dataRow, true); +#endif + + // get rotation of marker + nRotations = predict_id%4; + // if _rotateMarkers, interchange rotation 1 and 3 + if(_rotateMarkers) + if(nRotations==1 || nRotations==3) nRotations = nRotations==1?3:1; + + // if dictSize is known (dictSize!=-1), and the marker id is equal to the number of markers * 4 + // then it is the invalid marker class + if(_dictSize!=-1 && predict_id==_dictSize*4) return false; + // else, divide by 4 to obtain the final marker id + mid= predict_id/4; + return true; + + } + +}; + +} +SVMMarkers::SVMMarkers(){ + _impl=new impl::SVMMarkers; +} + +bool SVMMarkers::load(string path) { + return _impl->load(path); +} + +/** + * Detect marker in a canonical image. + * Return marker id in 0 rotation, or -1 if not found + * Assign the detected rotation of the marker to nRotation + */ +bool SVMMarkers::detect(const cv::Mat &in, int &marker_id, int &nRotations, string &additionalInfo) { + bool res=_impl->detect(in,marker_id,nRotations); + if (res) additionalInfo="SVM"; + return res; +} +int SVMMarkers::getBestInputSize(){return _impl->getBestInputSize();} + +} diff --git a/src/include/aruco/markerlabelers/svmmarkers.h b/src/aruco/markerlabelers/svmmarkers.h old mode 100644 new mode 100755 similarity index 100% rename from src/include/aruco/markerlabelers/svmmarkers.h rename to src/aruco/markerlabelers/svmmarkers.h diff --git a/src/aruco/markermap.cpp b/src/aruco/markermap.cpp new file mode 100644 index 0000000..fc89680 --- /dev/null +++ b/src/aruco/markermap.cpp @@ -0,0 +1,466 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "markermap.h" +#include "dictionary.h" + +#include +#include + +#include + +using namespace std; +using namespace cv; + +namespace aruco +{ +Marker3DInfo::Marker3DInfo(){} +Marker3DInfo::Marker3DInfo(int _id):id(_id){} + /** + * + * + */ + MarkerMap::MarkerMap() + { + mInfoType = NONE; + } + /** + * + * + */ + MarkerMap::MarkerMap(string filePath) + { + mInfoType = NONE; + readFromFile(filePath); + } + + /** + * + * + */ + void MarkerMap::saveToFile(string sfile) + { + cv::FileStorage fs(sfile, cv::FileStorage::WRITE); + saveToFile(fs); + } + /**Saves the board info to a file + */ + void MarkerMap::saveToFile(cv::FileStorage& fs) + { + fs << "aruco_bc_dict" << dictionary; + fs << "aruco_bc_nmarkers" << (int)size(); + fs << "aruco_bc_mInfoType" << (int)mInfoType; + fs << "aruco_bc_markers" + << "["; + for (size_t i = 0; i < size(); i++) + { + fs << "{:" + << "id" << at(i).id; + + fs << "corners" + << "[:"; + for (size_t c = 0; c < at(i).size(); c++) + fs << at(i)[c]; + fs << "]"; + fs << "}"; + } + fs << "]"; + } + + /** + * + * + */ + void MarkerMap::readFromFile(string sfile) + { + try + { + cv::FileStorage fs(sfile, cv::FileStorage::READ); + if (!fs.isOpened()) + throw cv::Exception(81818, "MarkerMap::readFromFile", string(" file not opened ") + sfile, __FILE__,__LINE__); + readFromFile(fs); + } + catch (std::exception& ex) + { + throw cv::Exception(81818, "MarkerMap::readFromFile", ex.what() + string(" file=)") + sfile, __FILE__,__LINE__); + } + } + + /**Reads board info from a file + */ + void MarkerMap::readFromFile(cv::FileStorage& fs) + { + int aux = 0; + // look for the nmarkers + if (fs["aruco_bc_nmarkers"].name() != "aruco_bc_nmarkers") + throw cv::Exception(81818, "MarkerMap::readFromFile", "invalid file type", __FILE__, __LINE__); + fs["aruco_bc_nmarkers"] >> aux; + resize(aux); + fs["aruco_bc_mInfoType"] >> mInfoType; + cv::FileNode markers = fs["aruco_bc_markers"]; + int i = 0; + for (FileNodeIterator it = markers.begin(); it != markers.end(); ++it, i++) + { + at(i).id = (*it)["id"]; + FileNode FnCorners = (*it)["corners"]; + for (FileNodeIterator itc = FnCorners.begin(); itc != FnCorners.end(); ++itc) + { + vector coordinates3d; + (*itc) >> coordinates3d; + if (coordinates3d.size() != 3) + throw cv::Exception(81818, "MarkerMap::readFromFile", "invalid file type 3", __FILE__, __LINE__); + cv::Point3f point(coordinates3d[0], coordinates3d[1], coordinates3d[2]); + at(i).push_back(point); + } + } + + if (fs["aruco_bc_dict"].name() == "aruco_bc_dict") + fs["aruco_bc_dict"] >> dictionary; + } + + /** + */ + int MarkerMap::getIndexOfMarkerId(int id) const + { + for (size_t i = 0; i < size(); i++) + if (at(i).id == id) + return static_cast(i); + return -1; + } + + /** + */ + const Marker3DInfo& MarkerMap::getMarker3DInfo(int id) const + { + for (size_t i = 0; i < size(); i++) + if (at(i).id == id) + return at(i); + throw cv::Exception(111, "MarkerMap::getMarker3DInfo", "Marker with the id given is not found", __FILE__, + __LINE__); + } + + void __glGetModelViewMatrix(double modelview_matrix[16], const cv::Mat& Rvec, + const cv::Mat& Tvec) + { + // check if paremeters are valid + bool invalid = false; + for (int i = 0; i < 3 && !invalid; i++) + { + if (Tvec.at(i, 0) != -999999) + invalid |= false; + if (Rvec.at(i, 0) != -999999) + invalid |= false; + } + if (invalid) + throw cv::Exception(9002, "extrinsic parameters are not set", "Marker::getModelViewMatrix", __FILE__, + __LINE__); + Mat Rot(3, 3, CV_32FC1), Jacob; + Rodrigues(Rvec, Rot, Jacob); + + double para[3][4]; + for (int i = 0; i < 3; i++) + for (int j = 0; j < 3; j++) + para[i][j] = Rot.at(i, j); + // now, add the translation + para[0][3] = Tvec.at(0, 0); + para[1][3] = Tvec.at(1, 0); + para[2][3] = Tvec.at(2, 0); + double scale = 1; + + modelview_matrix[0 + 0 * 4] = para[0][0]; + // R1C2 + modelview_matrix[0 + 1 * 4] = para[0][1]; + modelview_matrix[0 + 2 * 4] = para[0][2]; + modelview_matrix[0 + 3 * 4] = para[0][3]; + // R2 + modelview_matrix[1 + 0 * 4] = para[1][0]; + modelview_matrix[1 + 1 * 4] = para[1][1]; + modelview_matrix[1 + 2 * 4] = para[1][2]; + modelview_matrix[1 + 3 * 4] = para[1][3]; + // R3 + modelview_matrix[2 + 0 * 4] = -para[2][0]; + modelview_matrix[2 + 1 * 4] = -para[2][1]; + modelview_matrix[2 + 2 * 4] = -para[2][2]; + modelview_matrix[2 + 3 * 4] = -para[2][3]; + modelview_matrix[3 + 0 * 4] = 0.0; + modelview_matrix[3 + 1 * 4] = 0.0; + modelview_matrix[3 + 2 * 4] = 0.0; + modelview_matrix[3 + 3 * 4] = 1.0; + if (scale != 0.0) + { + modelview_matrix[12] *= scale; + modelview_matrix[13] *= scale; + modelview_matrix[14] *= scale; + } + } + + /**** + * + */ + void __OgreGetPoseParameters(double position[3], double orientation[4], const cv::Mat& Rvec, + const cv::Mat& Tvec) + { + // check if paremeters are valid + bool invalid = false; + for (int i = 0; i < 3 && !invalid; i++) + { + if (Tvec.at(i, 0) != -999999) + invalid |= false; + if (Rvec.at(i, 0) != -999999) + invalid |= false; + } + if (invalid) + throw cv::Exception(9003, "extrinsic parameters are not set", "Marker::getModelViewMatrix", __FILE__, + __LINE__); + + // calculate position vector + position[0] = -Tvec.ptr(0)[0]; + position[1] = -Tvec.ptr(0)[1]; + position[2] = +Tvec.ptr(0)[2]; + + // now calculare orientation quaternion + cv::Mat Rot(3, 3, CV_32FC1); + cv::Rodrigues(Rvec, Rot); + + // calculate axes for quaternion + double stAxes[3][3]; + // x axis + stAxes[0][0] = -Rot.at(0, 0); + stAxes[0][1] = -Rot.at(1, 0); + stAxes[0][2] = +Rot.at(2, 0); + // y axis + stAxes[1][0] = -Rot.at(0, 1); + stAxes[1][1] = -Rot.at(1, 1); + stAxes[1][2] = +Rot.at(2, 1); + // for z axis, we use cross product + stAxes[2][0] = stAxes[0][1] * stAxes[1][2] - stAxes[0][2] * stAxes[1][1]; + stAxes[2][1] = -stAxes[0][0] * stAxes[1][2] + stAxes[0][2] * stAxes[1][0]; + stAxes[2][2] = stAxes[0][0] * stAxes[1][1] - stAxes[0][1] * stAxes[1][0]; + + // transposed matrix + double axes[3][3]; + axes[0][0] = stAxes[0][0]; + axes[1][0] = stAxes[0][1]; + axes[2][0] = stAxes[0][2]; + + axes[0][1] = stAxes[1][0]; + axes[1][1] = stAxes[1][1]; + axes[2][1] = stAxes[1][2]; + + axes[0][2] = stAxes[2][0]; + axes[1][2] = stAxes[2][1]; + axes[2][2] = stAxes[2][2]; + + // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes + // article "Quaternion Calculus and Fast Animation". + double fTrace = axes[0][0] + axes[1][1] + axes[2][2]; + double fRoot; + + if (fTrace > 0.0) + { + // |w| > 1/2, may as well choose w > 1/2 + fRoot = sqrt(fTrace + 1.0); // 2w + orientation[0] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; // 1/(4w) + orientation[1] = (axes[2][1] - axes[1][2]) * fRoot; + orientation[2] = (axes[0][2] - axes[2][0]) * fRoot; + orientation[3] = (axes[1][0] - axes[0][1]) * fRoot; + } + else + { + // |w| <= 1/2 + static unsigned int s_iNext[3] = {1, 2, 0}; + unsigned int i = 0; + if (axes[1][1] > axes[0][0]) + i = 1; + if (axes[2][2] > axes[i][i]) + i = 2; + unsigned int j = s_iNext[i]; + unsigned int k = s_iNext[j]; + + fRoot = sqrt(axes[i][i] - axes[j][j] - axes[k][k] + 1.0); + double* apkQuat[3] = {&orientation[1], &orientation[2], &orientation[3]}; + *apkQuat[i] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + orientation[0] = (axes[k][j] - axes[j][k]) * fRoot; + *apkQuat[j] = (axes[j][i] + axes[i][j]) * fRoot; + *apkQuat[k] = (axes[k][i] + axes[i][k]) * fRoot; + } + } + + /** + */ + void MarkerMap::getIdList(std::vector& ids, bool append) const + { + if (!append) + ids.clear(); + for (size_t i = 0; i < size(); i++) + ids.push_back(at(i).id); + } + + MarkerMap MarkerMap::convertToMeters(float markerSize_meters)const + { + if (!isExpressedInPixels()) + throw cv::Exception(-1, "The board is not expressed in pixels", "MarkerMap::convertToMeters", __FILE__, + __LINE__); + // first, we are assuming all markers are equally sized. So, lets get the size in pixels + int markerSizePix = static_cast(cv::norm(at(0)[0] - at(0)[1])); + MarkerMap BInfo(*this); + BInfo.mInfoType = MarkerMap::METERS; + // now, get the size of a pixel, and change scale + float pixSize = markerSize_meters / float(markerSizePix); + cout << markerSize_meters << " " << float(markerSizePix) << " " << pixSize << endl; + for (size_t i = 0; i < BInfo.size(); i++) + for (int c = 0; c < 4; c++) + { + BInfo[i][c] *= pixSize; + } + return BInfo; + } + cv::Mat MarkerMap::getImage(float METER2PIX) const + { + if (mInfoType == NONE) + throw cv::Exception(-1, "The board is not valid mInfoType==NONE ", "MarkerMap::getImage", __FILE__, + __LINE__); + if (METER2PIX <= 0 && mInfoType != PIX) + throw cv::Exception(-1, "The board is not expressed in pixels and not METER2PIX indicated", + "MarkerMap::getImage", __FILE__, __LINE__); + + auto Dict = Dictionary::loadPredefined(dictionary); + + // get image limits + cv::Point pmin(std::numeric_limits::max(), std::numeric_limits::max()), + pmax(std::numeric_limits::lowest(), std::numeric_limits::lowest()); + for (auto b : *this) + { + for (auto p : b.points) + { + pmin.x = min(int(p.x), pmin.x); + pmin.y = min(int(p.y), pmin.y); + pmax.x = max(int(p.x + 0.5), pmax.x); + pmax.y = max(int(p.y + 0.5), pmax.y); + assert(p.z == 0); + } + } + + cv::Point psize = pmax - pmin; + cv::Mat image(cv::Size(psize.x, psize.y), CV_8UC1); + image.setTo(cv::Scalar::all(255)); + + vector p3d = *this; + // the points must be moved from a real reference system to image reference sysmte (y positive is inverse) + for (auto& m : p3d) + for (auto& p : m.points) + { + p -= cv::Point3f(static_cast(pmin.x), static_cast(pmax.y), 0.f); + // now, use inverse y + p.y = -p.y; + } + for (auto m : p3d) + { + // get size and find size of this + const float size = static_cast(cv::norm(m[0] - m[1])); + auto im1 = Dict.getMarkerImage_id(m.id, int(size / 8)); + cv::Mat im2; + // now resize to fit + cv::resize(im1, im2, cv::Size(static_cast(size), static_cast(size))); + // copy in correct position + auto ry = cv::Range(int(m[0].y), int(m[2].y)); + auto rx = cv::Range(int(m[0].x), int(m[2].x)); + cv::Mat sub = image(ry, rx); + im2.copyTo(sub); + } + return image; + } + + std::vector MarkerMap::getIndices(const vector& markers)const + { + std::vector indices; + for (size_t i = 0; i < markers.size(); i++) + { + bool found = false; + for (size_t j = 0; j < size() && !found; j++) + { + if (markers[i].id == at(j).id) + { + found = true; + indices.push_back(static_cast(i)); + } + } + } + return indices; + } + void MarkerMap::toStream(std::ostream& str) + { + str << mInfoType << " " << size() << " "; + for (size_t i = 0; i < size(); i++) + { + at(i).toStream(str); + } + // write dic string info + str << dictionary; + } + void MarkerMap::fromStream(std::istream& str) + { + int s; + str >> mInfoType >> s; + resize(s); + for (size_t i = 0; i < size(); i++) + at(i).fromStream(str); + str >> dictionary; + } + pair MarkerMap::calculateExtrinsics(const std::vector& markers, float markerSize, + cv::Mat CameraMatrix, cv::Mat Distorsion) + { + vector p2d; + MarkerMap m_meters; + if (isExpressedInPixels()) + m_meters = convertToMeters(markerSize); + else + m_meters = *this; + vector p3d; + for (auto marker : markers) + { + auto it = find(m_meters.begin(), m_meters.end(), marker.id); + if (it != m_meters.end()) + { // is the marker part of the map? + for (auto p : marker) + p2d.push_back(p); + for (auto p : it->points) + p3d.push_back(p); + } + } + + cv::Mat rvec, tvec; + if (p2d.size() != 0) + { // no points in the vector + cv::solvePnPRansac(p3d, p2d, CameraMatrix, Distorsion, rvec, tvec); + } + return make_pair(rvec, tvec); + } +}; diff --git a/src/include/aruco/markermap.h b/src/aruco/markermap.h similarity index 98% rename from src/include/aruco/markermap.h rename to src/aruco/markermap.h index 10f3fcf..81ce808 100644 --- a/src/include/aruco/markermap.h +++ b/src/aruco/markermap.h @@ -32,7 +32,7 @@ or implied, of Rafael Muñoz Salinas. #include "aruco_export.h" #include "marker.h" -#include +#include #include #include @@ -131,7 +131,7 @@ or implied, of Rafael Muñoz Salinas. } /**converts the passed board into meters */ - MarkerMap convertToMeters(float markerSize); + MarkerMap convertToMeters(float markerSize) const; // simple way of knowing which elements detected in an image are from this markermap // returns the indices of the elements in the vector 'markers' that belong to this set // Example: The set has the elements with ids 10,21,31,41,92 diff --git a/src/aruco/picoflann.h b/src/aruco/picoflann.h new file mode 100644 index 0000000..ea0ca96 --- /dev/null +++ b/src/aruco/picoflann.h @@ -0,0 +1,709 @@ +/** +* This file is part of UCOSLAM +* +* Copyright (C) 2018 Rafael Munoz Salinas (University of Cordoba) +* +* UCOSLAM is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* UCOSLAM is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with UCOSLAM. If not, see gnu.org/licenses/>. +*/ +#ifndef PicoFlann_H +#define PicoFlann_H +#include +#include +#include +#include +#include +#include +#include +#include +namespace picoflann { + + +/** + * @brief The KdTreeIndex class is the simplest an minimal method to use kdtrees. + * You only must define an adapter, that tells the class how to access the i-th dimension of your element. Here are two examples showing how easy it is: + * + * You can use any container providing the methods size() ant at(). + * You must create the adapter that must implement the method : T operator( )(const E &elem, int dim)const; T=float or double, E is your element type + * + * You can easily save/read the index to/from an stream using toStream() and fromStream(). Please notice that the data of the container is not copied in the KdTreeIndex so you + * must be sure it is available when doing the searchs + * + * See examples below + + * +#include +#include +#include +#include "picoflann.h" +void example1(){ + //Data type + struct Point2f{ + Point2f(float X,float Y) { x=X;y=Y; } + float x,y; + }; + + // Adapter. + // Given an Point2f element, it returns the element of the dimension specified such that dim=0 is x and dim=1 is y + struct PicoFlann_Point2fAdapter{ + inline float operator( )(const Point2f &elem, int dim)const { return dim==0?elem.x:elem.y; } + }; + + //create the points randomly + std::default_random_engine generator; + std::uniform_real_distribution distribution(-1000.0,1000.0); + std::vector data; + for(size_t i=0;i<1000;i++) + data.push_back( Point2f ( distribution(generator),distribution(generator))); + ///------------------------------------------------------------ + /// Create the kdtree + picoflann::KdTreeIndex<2,PicoFlann_Point2fAdapter> kdtree;//2 is the number of dimensions + kdtree.build(data); + //search 10 nearest neibors to point (0,0) + std::vector > res=kdtree.searchKnn(data,Point2f(0,0),10); + + //radius search in a radius of 30 (the resulting distances are squared) + res=kdtree.radiusSearch(data,Point2f(0,0),30); + //another version + kdtree.radiusSearch(res,data,Point2f(0,0),30); + + //you can save to a file + std::ofstream file_out("out.bin",std::ios::binary); + kdtree.toStream(file_out); + + //recover from the file + picoflann::KdTreeIndex<2,PicoFlann_Point2fAdapter> kdtree2; + std::ifstream file_in("out.bin",std::ios::binary); + kdtree2.fromStream(file_in); + res=kdtree2.radiusSearch(data,Point2f(0,0),30); + +} + + +//Using an array of 3d points +void example2(){ + + struct Point3f{ + Point3f(float X,float Y,float Z) { data[0]=X;data[1]=Y;data[2]=Z; } + float data[3]; + }; + struct PicoFlann_Array3f_Adapter{ + inline float operator( )(const Point3f &elem, int dim)const{ return elem.data[dim]; } + }; + struct PicoFlann_Array3f_Container{ + const Point3f *_array; + size_t _size; + PicoFlann_Array3f_Container(float *array,size_t Size):_array((Point3f*)array),_size(Size){} + inline size_t size()const{return _size;} + inline const Point3f &at(int idx)const{ return _array [idx];} + }; + std::default_random_engine generator; + std::uniform_real_distribution distribution(-1000.0,1000.0); + + int nPoints=1000; + float *array=new float[nPoints*3]; + for(size_t i=0;i<1000*3;i++) + array[i]= distribution(generator); + + ///------------------------------------------------------------ + picoflann::KdTreeIndex<3,PicoFlann_Array3f_Adapter> kdtree;// 3 is the number of dimensions, L2 is the type of distance + kdtree.build( PicoFlann_Array3f_Container(array,nPoints)); + PicoFlann_Array3f_Container p3container(array,nPoints); + std::vector > res=kdtree.searchKnn(p3container,Point3f(0,0,0),10); + res=kdtree.radiusSearch(p3container,Point3f(0,0,0),30); +} + * + */ +struct L2{ + + template + double compute_distance( const ElementType &elema,const ElementType &elemb,const Adapter & adapter,int ndims ,double worstDist)const + { + //compute dist + double sqd=0; + for(int i=0;iworstDist) return sqd; + } + return sqd; + } +}; + +template +class KdTreeIndex{ + +public: + /** + *Builds the index using the data passes in your container and the adapter + */ + template + inline void build(const Container &container ){ + _index.clear(); + _index.reserve(container.size()*2); + _index.dims=DIMS; + _index.nValues=container.size(); + //Create root and assign all items + all_indices.resize(container.size()); + for(size_t i=0;i(_index.rootBBox,0,all_indices.size(),container); + _index.push_back(Node()); + divideTree(_index,0,0,all_indices.size(),_index.rootBBox ,container); + } + + + inline void clear(){ + _index.clear(); + all_indices.clear(); + } + + //saves to a stream. Note that the container is not saved! + inline void toStream (std::ostream &str)const; + //reads from an stream. Note that the container is not readed! + inline void fromStream (std::istream &str); + + template< typename Type,typename Container > + inline std::vector > searchKnn(const Container &container,const Type &val, int nn,bool sorted=true){ + std::vector > res; + generalSearch(res,container,val,-1,sorted,nn); + return res; + } + + + template< typename Type,typename Container > + inline std::vector > radiusSearch(const Container &container,const Type &val, double dist,bool sorted=true, int maxNN=-1)const{ + std::vector > res; + generalSearch< Type,Container>(res,container,val,dist,sorted,maxNN); + return res; + } + + + template< typename Type,typename Container > + inline void radiusSearch(std::vector > &res,const Container &container,const Type &val, double dist,bool sorted=true, int maxNN=-1){ + generalSearch(res,container,val,dist,sorted,maxNN); + } + + + + //computes a hash number from the index + uint64_t getHash()const; +private: + + struct Node{ + inline bool isLeaf()const{return _ileft==-1 && _iright==-1;} + inline void setNodesInfo(uint32_t l,uint32_t r){_ileft=l; _iright=r;} + double div_val; + uint16_t col_index;//column index of the feature vector + std::vector idx; + float divhigh,divlow; + int64_t _ileft=-1,_iright=-1;//children + void toStream(std::ostream &str) const; + void fromStream(std::istream &str); + }; + + + typedef std::vector > BoundingBox; + + struct Index:public std::vector{ + Index(int Dims){ + dims=Dims; + rootBBox.resize(dims); + } + BoundingBox rootBBox; + int dims=0; + int nValues=0;//number of elements of the set when call to build + inline void toStream(std::ostream &str)const; + inline void fromStream(std::istream &str); + }; + Index _index=Index(DIMS); + DistanceType _distance; + Adapter adapter; + //next are only used during build + std::vector all_indices; + int _maxLeafSize=10 ; + + + + //temporal used during creation of the tree + template< typename Container > + void divideTree(Index &index,uint64_t nodeIdx,int startIndex,int endIndex ,BoundingBox &bbox,const Container&container){ + // std::cout<<"CREATE="<(bbox,startIndex,endIndex,container); + // std::cout<(_bbox,startIndex,endIndex,container); + // //get the dimension with highest distnaces + double max_spread=-1; + currNode.col_index=0; + for(int i=0;imax_spread){ + max_spread=spread; + currNode.col_index=i; + } + } + //select the split val + double split_val= (bbox[currNode.col_index].first + bbox[currNode.col_index].second) / 2; + if (split_val < _bbox[currNode.col_index].first) currNode.div_val = _bbox[currNode.col_index].first; + else if (split_val > _bbox[currNode.col_index].second ) currNode.div_val = _bbox[currNode.col_index].second ; + else currNode.div_val = split_val; + } + else{ + ///SELECT THE COL (DIMENSION) ON WHICH PARTITION IS MADE + double var[DIMS],mean[DIMS]; + //compute the variance of the features to select the highest one + mean_var_calculate(startIndex,endIndex, var, mean,container); + currNode.col_index=0; + //select element with highest variance + for(int i=1;ivar[currNode.col_index]) currNode.col_index=i; + + //now sort all indices according to the selected value + + currNode.div_val=mean[currNode.col_index]; + } + + + + + + //compute the variance of the features to select the highest one + //now sort all indices according to the selected value + + //std::cout<<" CUT FEAT="< +void KdTreeIndex::toStream (std::ostream &str)const{ +_index.toStream(str); +} + +template +void KdTreeIndex::fromStream(std::istream &str){ +_index.fromStream(str); +} + +template +uint64_t KdTreeIndex:: getHash()const{ + + auto toUint64=[](double val){ + uint64_t *ui=(uint64_t *)&val; + return *ui; + }; + uint64_t seed=_index.dims; + seed ^= _index.nValues+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + for(size_t i=0;i<_index.rootBBox.size();i++){ + seed ^= toUint64(_index.rootBBox[i].first) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= toUint64(_index.rootBBox[i].second)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + } + for(size_t i=0;i<_index.size();i++){ + const auto &node=_index.at(i); + seed ^= toUint64(node.div_val)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= node.col_index+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= toUint64(node.divhigh)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= toUint64(node.divlow)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= node._ileft+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= node._iright+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + for(auto v:node.idx) + seed ^= v+ 0x9e3779b9 + (seed << 6) + (seed >> 2); + } + + + return seed; +} + +} + +#endif + diff --git a/src/aruco/posetracker.cpp b/src/aruco/posetracker.cpp new file mode 100644 index 0000000..c23adb9 --- /dev/null +++ b/src/aruco/posetracker.cpp @@ -0,0 +1,559 @@ +/** +Copyright 2017 Rafael Muñoz Salinas. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of Rafael Muñoz Salinas. +*/ + +#include "posetracker.h" +#include "ippe.h" +#include +#if CV_MAJOR_VERSION < 3 +#include "levmarq.h" +#else +#endif +#include +namespace aruco +{ + +namespace aruco_private { + +cv::Mat impl__aruco_getRTMatrix(const cv::Mat& _rvec, const cv::Mat& _tvec) +{ + assert(_rvec.type()==CV_32F && _rvec.total()==3); + assert(_tvec.type()==CV_32F && _tvec.total()==3); + + cv::Mat Matrix(4,4,CV_32F); + float *rt_44=Matrix.ptr(0); + //makes a fast conversion to the 4x4 array passed + float rx=_rvec.ptr(0)[0]; + float ry=_rvec.ptr(0)[1]; + float rz=_rvec.ptr(0)[2]; + float tx=_tvec.ptr(0)[0]; + float ty=_tvec.ptr(0)[1]; + float tz=_tvec.ptr(0)[2]; + float nsqa=rx*rx + ry*ry + rz*rz; + float a=std::sqrt(nsqa); + float i_a=a?1./a:0; + float rnx=rx*i_a; + float rny=ry*i_a; + float rnz=rz*i_a; + float cos_a=cos(a); + float sin_a=sin(a); + float _1_cos_a=1.-cos_a; + rt_44[0] =cos_a+rnx*rnx*_1_cos_a; + rt_44[1]=rnx*rny*_1_cos_a- rnz*sin_a; + rt_44[2]=rny*sin_a + rnx*rnz*_1_cos_a; + rt_44[3]=tx; + rt_44[4]=rnz*sin_a +rnx*rny*_1_cos_a; + rt_44[5]=cos_a+rny*rny*_1_cos_a; + rt_44[6]= -rnx*sin_a+ rny*rnz*_1_cos_a; + rt_44[7]=ty; + rt_44[8]= -rny*sin_a + rnx*rnz*_1_cos_a; + rt_44[9]= rnx*sin_a + rny*rnz*_1_cos_a; + rt_44[10]=cos_a+rnz*rnz*_1_cos_a; + rt_44[11]=tz; + rt_44[12]=rt_44[13]=rt_44[14]=0; + rt_44[15]=1; + return Matrix; +} +void impl__aruco_getRTfromMatrix44(const cv::Mat& M, cv::Mat& R, cv::Mat& T) +{ + assert(M.cols == M.rows && M.cols == 4); + assert(M.type() == CV_32F || M.type() == CV_64F); + // extract the rotation part + cv::Mat r33 = cv::Mat(M, cv::Rect(0, 0, 3, 3)); + cv::SVD svd(r33); + cv::Mat Rpure = svd.u * svd.vt; + cv::Rodrigues(Rpure, R); + T.create(1, 3, M.type()); + if (M.type() == CV_32F) + for (int i = 0; i < 3; i++) + T.ptr(0)[i] = M.at(i, 3); + else + for (int i = 0; i < 3; i++) + T.ptr(0)[i] = M.at(i, 3); +} + +double reprj_error( const std::vector &objPoints, const std::vectorpoints2d, const CameraParameters &imp,const cv::Mat &rt44){ + std::vector prepj; + cv::Mat rv,tv; + impl__aruco_getRTfromMatrix44(rt44,rv,tv); + cv::projectPoints(objPoints,rv,tv,imp.CameraMatrix,imp.Distorsion,prepj); + double sum=0; + int nvalid=0; + for(size_t i=0;i& POrg, const std::vector& PDst, cv::Mat& RT_4x4) +{ + struct Quaternion + { + Quaternion(float q0, float q1, float q2, float q3) + { + q[0] = q0; + q[1] = q1; + q[2] = q2; + q[3] = q3; + } + cv::Mat getRotation() const + { + cv::Mat R(3, 3, CV_32F); + R.at(0, 0) = q[0] * q[0] + q[1] * q[1] - q[2] * q[2] - q[3] * q[3]; + R.at(0, 1) = 2.f * (q[1] * q[2] - q[0] * q[3]); + R.at(0, 2) = 2.f * (q[1] * q[3] + q[0] * q[2]); + + R.at(1, 0) = 2.f * (q[1] * q[2] + q[0] * q[3]); + R.at(1, 1) = q[0] * q[0] + q[2] * q[2] - q[1] * q[1] - q[3] * q[3]; + R.at(1, 2) = 2.f * (q[2] * q[3] - q[0] * q[1]); + + R.at(2, 0) = 2.f * (q[1] * q[3] - q[0] * q[2]); + R.at(2, 1) = 2.f * (q[2] * q[3] + q[0] * q[1]); + R.at(2, 2) = q[0] * q[0] + q[3] * q[3] - q[1] * q[1] - q[2] * q[2]; + return R; + } + float q[4]; + }; + assert(POrg.size()== PDst.size()); + + cv::Mat _org(POrg.size(),3,CV_32F,(float*)&POrg[0]); + cv::Mat _dst(PDst.size(),3,CV_32F,(float*)&PDst[0]); + + +// _org = _org.reshape(1); +// _dst = _dst.reshape(1); + cv::Mat Mu_s = cv::Mat::zeros(1, 3, CV_32F); + cv::Mat Mu_m = cv::Mat::zeros(1, 3, CV_32F); + // cout<<_s<(0)[i] /= float(_org.rows); + Mu_m.ptr(0)[i] /= float(_dst.rows); + } + + // cout<<"Mu_s="<(0, 0), eigenvectors.at(0, 1), eigenvectors.at(0, 2), + eigenvectors.at(0, 3)); + cv::Mat RR = rot.getRotation(); + // cout<<"RESULT="<& v_m){ + + + + //get the markers in v_m that are in the map + std::vector mapMarkers; + for (auto marker : v_m) + { + if (_map_mm.find(marker.id) != _map_mm.end()) + mapMarkers.push_back(marker); + } + + if( mapMarkers.size()==0)return cv::Mat(); + struct minfo{ + int id; + cv::Mat rt_f2m; + double err; + }; + struct se3{float rt[6];}; + + cv::Mat pose_f2g_out;//result + //estimate the markers locations and see if there is at least one good enough + std::vector good_marker_locations; + std::vector all_marker_locations; + + for(const Marker &marker:mapMarkers){//for ech visible marker + auto mpi=solvePnP_(_map_mm[marker.id]. getMarkerSize(),marker,_cam_params.CameraMatrix,_cam_params.Distorsion); + minfo mi; + mi.id=marker.id; + mi.err=mpi[0].second; + mi.rt_f2m=mpi[0].first; + all_marker_locations.push_back(mi); + if(mpi[1].second/mpi[0].second > aruco_minerrratio_valid) + good_marker_locations.push_back(mi); + mi.rt_f2m=mpi[1].first; + mi.err=mpi[1].second; + all_marker_locations.push_back(mi); + + } + + + //try using more than one marker approach + if (mapMarkers.size()>=2) { + //collect all the markers 3d locations + std::vector markerPoints2d; + std::vector markerPoints3d; + for(const Marker &marker:mapMarkers){ + markerPoints2d.insert(markerPoints2d.end(),marker.begin(),marker.end()); + auto p3d= _map_mm[marker.id].points; + markerPoints3d.insert(markerPoints3d.end(),p3d.begin(),p3d.end()); + } + + //take the all poses and select the one that minimizes the global reproj error + for(auto & ml:all_marker_locations){ + auto pose= ml.rt_f2m *marker_m2g[ml.id]; + //now, compute the repj error of all markers using this info + ml.err=aruco_private::reprj_error(markerPoints3d,markerPoints2d,_cam_params, pose); + } + //sort and get the best + std::sort(all_marker_locations.begin(),all_marker_locations.end(),[](const minfo &a,const minfo &b){return a.err -#include +#include namespace aruco { @@ -77,7 +77,7 @@ namespace aruco * @return true if the pose is estimated and false otherwise. If not estimated, the parameters m.Rvec and m.Tvec * and not set. */ - bool estimatePose(Marker& m, const CameraParameters& cam_params, float markerSize, float minErrorRatio = 4 /*tau_e in paper*/); + bool estimatePose(Marker& m, const CameraParameters& cam_params, float markerSize, float minErrorRatio = 10 /*tau_e in paper*/); // returns the 4x4 transform matrix. Returns an empty matrix if last call to estimatePose returned false cv::Mat getRTMatrix() const; @@ -140,6 +140,12 @@ namespace aruco { return _tvec; } + //prevents from big jumps. If the difference between current and previous positions are greater than the value indicated + //assumes no good tracking and the pose will be set as null + void setMaxTrackingDifference(float maxTranslation,float maxAngle){ + _maxTranslation=maxTranslation; + _maxAngle=maxAngle; + } private: cv::Mat _rvec, _tvec; // current poses @@ -150,6 +156,7 @@ namespace aruco cv::Mat relocalization(const std::vector& v_m); float aruco_minerrratio_valid;/*tau_e in paper*/ std::map marker_m2g;//for each marker, the transform from the global ref system to the marker ref system + float _maxTranslation=-1,_maxAngle=-1; }; }; diff --git a/src/include/aruco/timers.h b/src/aruco/timers.h similarity index 100% rename from src/include/aruco/timers.h rename to src/aruco/timers.h diff --git a/swigbuild.sh b/swigbuild.sh index 872b831..08045e1 100755 --- a/swigbuild.sh +++ b/swigbuild.sh @@ -23,8 +23,8 @@ mkdir py2 &> /dev/null mkdir py3 &> /dev/null # creates wrapper for py2 and py3 -swig -c++ -python -I./src/include -outdir py2 -I/usr/local/include aruco.i -swig -c++ -python -py3 -I./src/include -outdir py3 -I/usr/local/include aruco.i +swig -c++ -python -I./src/include -outdir py2 -Isrc aruco.i +swig -c++ -python -py3 -I./src/include -outdir py3 -Isrc aruco.i # builds shared library ${PYTHON_INTERPRETER} setup.py build_ext --inplace \ No newline at end of file From 2fa91fdddf1bd2c14e4a6f8b47e657a6dc399426 Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Tue, 26 Feb 2019 14:57:45 +0100 Subject: [PATCH 05/22] Python wheel compatible setup Updated pypi package to 3.0.13.0 --- LICENSE.txt => LICENSE | 0 MANIFEST.in | 3 +- build_wheel.sh | 23 +++++ setup.cfg | 5 + setup.py | 11 +- src/aruco.i | 221 ----------------------------------------- 6 files changed, 39 insertions(+), 224 deletions(-) rename LICENSE.txt => LICENSE (100%) create mode 100755 build_wheel.sh create mode 100644 setup.cfg delete mode 100644 src/aruco.i diff --git a/LICENSE.txt b/LICENSE similarity index 100% rename from LICENSE.txt rename to LICENSE diff --git a/MANIFEST.in b/MANIFEST.in index 07c4ed6..85b0c66 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,4 +1,5 @@ recursive-include src * recursive-include py2 * recursive-include py3 * -include aruco_wrap.* \ No newline at end of file +include aruco_wrap.* +LICENSE diff --git a/build_wheel.sh b/build_wheel.sh new file mode 100755 index 0000000..2fa442c --- /dev/null +++ b/build_wheel.sh @@ -0,0 +1,23 @@ +#!/bin/bash +# based on instruction at: https://hynek.me/articles/sharing-your-labor-of-love-pypi-quick-and-dirty/ + +# cleanup +rm -rf build + +# build python2 wheel +python setup.py sdist bdist_wheel + +# build python3 wheel +python3 setup.py sdist bdist_wheel + +# create python2 env and run example +rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.0.13.0-cp27-cp27mu-linux_x86_64.whl && 27-sdist/bin/python example/example.py + +# create python3 env and run example +rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.0.13.0-cp36-cp36m-linux_x86_64.whl && 36-sdist/bin/python example/example.py + +# test .tar.gz without wheel +# create python2 env and run example +rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.0.13.0.tar.gz && 27-sdist/bin/python example/example.py +# create python3 env and run example +rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.0.13.0.tar.gz && 36-sdist/bin/python example/example.py \ No newline at end of file diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..791894a --- /dev/null +++ b/setup.cfg @@ -0,0 +1,5 @@ +[bdist_wheel] +universal = 0 + +[metadata] +license_file = LICENSE \ No newline at end of file diff --git a/setup.py b/setup.py index cea43e7..a9d22f9 100644 --- a/setup.py +++ b/setup.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- import platform -from distutils.core import setup, Extension +from setuptools import setup, Extension import shutil import sys import glob @@ -12,6 +12,10 @@ else: shutil.copy("./py3/aruco.py", ".") +with open("README.md", "r") as fh: + long_description = fh.read() +with open("LICENSE", "r") as fh: + license = fh.read() sourcefiles = ['aruco_wrap.cxx'] sourcefiles.extend(glob.glob("src/aruco/*.cpp")) @@ -36,9 +40,12 @@ author="""ArUco: Rafael Muñoz Salinas, Python wrappers: Marcus Degenkolbe""", author_email='marcus@degenkolbe.eu', description="""ArUco Python wrappers""", + long_description=long_description, + long_description_content_type="text/markdown", + license=license, url='https://github.com/fehlfarbe/python-aruco', keywords='aruco wrapper', - install_requires=['numpy'], + install_requires=['numpy', 'opencv-contrib-python'], ext_modules=[aruco_module], py_modules=["aruco"], ) diff --git a/src/aruco.i b/src/aruco.i deleted file mode 100644 index 8680a8e..0000000 --- a/src/aruco.i +++ /dev/null @@ -1,221 +0,0 @@ -/************************************ - -Swig Module for ArUco Python wrapper - -************************************/ - -// module name -%module(directors="1") aruco - -// needed -%include -%include "pyabc.i" -%include "std_vector.i" - -%{ - #define SWIG_FILE_WITH_INIT - using namespace std; -%} - -namespace std { - // for vector to Python list conversion - %template(VectorInt) vector; -}; - -// NumPy <--> OpenCV typemaps -%include "okapi-typemaps.i" -//%include -//%cv_instantiate_all_defaults - -/************************************ - -ArUco stuff - -************************************/ - - -%{ - #define SWIG_FILE_WITH_INIT - #include - #include - #include - #include - #include - #include - #include - //#include - #include - #include - #include - #include - #include - #include - #include - #include - - using namespace aruco; -%} - - - -%include -%include -%include -%include -%include -%include -//%include -%include - -// Marker is std::vector< cv::Point2f >, template definition -// needed for std::vector -> Python List conversion -%template(Point2fVec) std::vector< cv::Point2f >; -%template(MarkerVec) std::vector< aruco::Marker, std::allocator< aruco::Marker > >; -%template(VectorMarker3DInfo) std::vector< aruco::Marker3DInfo >; - -%include -/*** - Workaround: - std::vector.at() --> Point2f conversion doesn't work - so I just implemented the Python __getitem__() method for aruco::Marker - to get corner points of the Marker object and added VectorIterator to - support for-loops -***/ - -%pythoncode %{ -class VectorIterator(object): - - def __init__(self, pointerToVector): - self.pointerToVector = pointerToVector - self.index = -1 - - def __iter__(self): - return self - - def __next__(self): - self.index += 1 - if self.index < len(self.pointerToVector): - return self.pointerToVector[self.index] - else: - raise StopIteration - - def next(self): - self.index += 1 - if self.index < len(self.pointerToVector): - return self.pointerToVector[self.index] - else: - raise StopIteration -%} - -%extend aruco::Marker { - public: - cv::Point2f __getitem__(int i) { - return $self->at(i); - } -} - -%extend aruco::Marker { -%pythoncode { - def iterator(self): - return VectorIterator(self) - } -} - - -%include -%include -%include -%include -%include -%include -%include - - -/*************************************************************** - OLD STUFF -**************************************************************/ - -/* - -%extend aruco::BoardConfiguration { - public: - vector getIdList() { - vector list; - $self->getIdList(list); - return list; - } -} -*/ - -// Board is std::vector< aruco::Marker >, template definition -// needed for std::vector -> Python List conversion -/* -%template(MarkerVec) std::vector< aruco::Marker >; -%include "aruco/board.h" -%include "aruco/cvdrawingutils.h" -*/ - -// rename detect function because of polymorphism problems -//%rename("detect_mat") aruco::BoardDetector::detect(const cv::Mat&); - -// some stuff to support nested class MarkerCandidate in boarddetector.h - -// Suppress SWIG warning -//#pragma SWIG nowarn=SWIGWARN_PARSE_NESTED_CLASS -// nested class in markerdetector -/* -class MarkerCandidate : public aruco::Marker { - public: - MarkerCandidate() {} - MarkerCandidate(const aruco::Marker &M) : Maruco::arker(M) {} - MarkerCandidate(const MarkerCandidate &M) : aruco::Marker(M) { - contour = M.contour; - idx = M.idx; - } - MarkerCandidate &operator=(const MarkerCandidate &M) { - (*(aruco::Marker *)this) = (*(aruco::Marker *)&M); - contour = M.contour; - idx = M.idx; - return *this; - } - - vector< cv::Point > contour; // all the points of its contour - int idx; // index position in the global contour list -}; - -%{ - #include "aruco/markerdetector.h" -%} - -%include "aruco/markerdetector.h" -*/ -// add detect function that returns the detected markers -/* -%extend aruco::MarkerDetector { - - public: - std::vector< aruco::Marker > detect(const cv::Mat &input, - aruco::CameraParameters camParams, - float markerSizeMeters = -1, - bool setYPerperdicular = false) throw(cv::Exception) - { - std::vector< aruco::Marker > markers; - $self->detect(input, markers, camParams, markerSizeMeters, setYPerperdicular); - return markers; - }; -} - - - -%{ - // SWIG thinks that Inner is a global class, so we need to trick the C++ - // compiler into understanding this so called global type. - typedef aruco::MarkerDetector::MarkerCandidate MarkerCandidate; -%} - -%{ - #include "aruco/boarddetector.h" -%} - -%include "aruco/boarddetector.h" -*/ From 60373097ca4650bdc1fed5c51d0fa754da2fb800 Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Fri, 24 May 2019 15:29:51 +0200 Subject: [PATCH 06/22] Updated to aruco 3.1.2.0 --- README.md | 12 +- aruco.i | 35 +- aruco_wrap.cxx | 9461 ++++++--- build_wheel.sh | 8 +- example/example.py | 12 +- example/fractal.png | Bin 0 -> 31030 bytes example/fractal.py | 34 + example/fractal_test.jpg | Bin 0 -> 90373 bytes setup.py | 7 +- src/aruco/CMakeLists.txt | 64 +- src/aruco/aruco.h | 2 + src/aruco/aruco_cvversioning.h | 16 + src/aruco/dictionary.h | 4 + src/aruco/dictionary_based.cpp | 4583 +++++ src/aruco/dictionary_based.h | 2743 +++ src/aruco/fractaldetector.cpp | 145 + src/aruco/fractaldetector.h | 115 + src/aruco/fractallabelers/fractallabeler.cpp | 152 + src/aruco/fractallabelers/fractallabeler.h | 56 + src/aruco/fractallabelers/fractalmarker.cpp | 72 + src/aruco/fractallabelers/fractalmarker.h | 54 + .../fractallabelers/fractalmarkerset.cpp | 828 + src/aruco/fractallabelers/fractalmarkerset.h | 145 + .../fractallabelers/fractalposetracker.cpp | 947 + .../fractallabelers/fractalposetracker.h | 107 + src/aruco/ippe.cpp | 1199 +- src/aruco/ippe.h | 363 +- src/aruco/marker.cpp | 21 +- src/aruco/marker.h | 6 + src/aruco/markerdetector.cpp | 1378 +- src/aruco/markerdetector.h | 268 +- src/aruco/markerdetector_impl.cpp | 16552 ++++++++++++++++ src/aruco/markerdetector_impl.h | 3787 ++++ src/aruco/markerlabeler.cpp | 50 +- src/aruco/markerlabelers/dictionary_based.cpp | 290 - src/aruco/markerlabelers/dictionary_based.h | 69 - src/aruco/markerlabelers/svmmarkers.cpp | 179 - src/aruco/markerlabelers/svmmarkers.h | 73 - src/aruco/picoflann.h | 80 +- src/aruco/posetracker.cpp | 5 - src/aruco/timers.h | 21 + 41 files changed, 38122 insertions(+), 5821 deletions(-) create mode 100644 example/fractal.png create mode 100644 example/fractal.py create mode 100644 example/fractal_test.jpg create mode 100644 src/aruco/aruco_cvversioning.h create mode 100644 src/aruco/dictionary_based.cpp create mode 100644 src/aruco/dictionary_based.h create mode 100644 src/aruco/fractaldetector.cpp create mode 100644 src/aruco/fractaldetector.h create mode 100644 src/aruco/fractallabelers/fractallabeler.cpp create mode 100644 src/aruco/fractallabelers/fractallabeler.h create mode 100644 src/aruco/fractallabelers/fractalmarker.cpp create mode 100644 src/aruco/fractallabelers/fractalmarker.h create mode 100644 src/aruco/fractallabelers/fractalmarkerset.cpp create mode 100644 src/aruco/fractallabelers/fractalmarkerset.h create mode 100644 src/aruco/fractallabelers/fractalposetracker.cpp create mode 100644 src/aruco/fractallabelers/fractalposetracker.h create mode 100644 src/aruco/markerdetector_impl.cpp create mode 100644 src/aruco/markerdetector_impl.h delete mode 100644 src/aruco/markerlabelers/dictionary_based.cpp delete mode 100644 src/aruco/markerlabelers/dictionary_based.h delete mode 100755 src/aruco/markerlabelers/svmmarkers.cpp delete mode 100755 src/aruco/markerlabelers/svmmarkers.h diff --git a/README.md b/README.md index c16b31b..6856018 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ [SWIG](http://www.swig.org/) generated Python wrappers for ArUco library. Works with OpenCV Python module cv2 resp. numpy array data types. -Tested on Linux Mint 19 x86_64, OpenCV 3.4.5, ArUco 3.0.13 Python 2.7.15 and NumPy 1.13.3 +Tested on Linux Mint 19 x86_64, OpenCV 4.1.0, ArUco 3.1.2 Python 3.6.1 and NumPy 1.16.3 Installation via pip -------------------- @@ -18,8 +18,8 @@ Installation Python2 5. run `./swigbuild.sh`: it compiles the shared library (_aruco.so) and generates Python wrappers (aruco.py) 6. run `sudo python setup.py install` to install the library globally -Installation Python3 (experimental) ------------------------------------ +Installation Python3 +-------------------- 1. Install / compile [OpenCV](http://opencv.org/) >= 2.4.9 with Python3 support. [Install-OpenCV script helps to install the latest version.](https://github.com/jayrambhia/Install-OpenCV/) 3. Install swig3: `sudo apt-get install swig3.0` for Debian/Ubuntu like systems. On 14.04 and other older systems you will need to go to "Software Sources" and check backports in the Updates tab, and reload before installing. @@ -30,13 +30,17 @@ Installation Python3 (experimental) Test ---- +#### example video open a prompt in `example/` and run: `python ./example.py` or `python3 ./example.py` for Python3 (depends on your default Python interpreter) +#### fractal marker example +open a prompt in `example/` and run: `python ./fractal.py` or `python3 ./fractal.py` for Python3 (depends on your default Python interpreter) + If the Python doesn't find some shared objects, add the library location to LD_LIBRARY_PATH: `export LD_LIBRARY_PATH=/usr/local/lib/:$LD_LIBRARY_PATH` Problems -------- -This wrapper is totally in beta state. I just tested some basic functions with `example/example.py`. +I just tested some basic functions with `example/example.py` / `example/fractal.py`. Please report errors and problems. diff --git a/aruco.i b/aruco.i index 8680a8e..e33829a 100644 --- a/aruco.i +++ b/aruco.i @@ -35,13 +35,14 @@ ArUco stuff %{ +/* #define SWIG_FILE_WITH_INIT #include #include #include #include #include - #include + //#include #include //#include #include @@ -52,7 +53,30 @@ ArUco stuff #include #include #include - +*/ + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include using namespace aruco; %} @@ -124,10 +148,13 @@ class VectorIterator(object): %include %include +%include %include %include -%include -%include +%include +%include +%include +%include %include diff --git a/aruco_wrap.cxx b/aruco_wrap.cxx index 87c10de..5bfe523 100644 --- a/aruco_wrap.cxx +++ b/aruco_wrap.cxx @@ -3451,64 +3451,83 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ -#define SWIGTYPE_p_Marker swig_types[0] -#define SWIGTYPE_p_allocator_type swig_types[1] -#define SWIGTYPE_p_aruco__CameraParameters swig_types[2] -#define SWIGTYPE_p_aruco__CvDrawingUtils swig_types[3] -#define SWIGTYPE_p_aruco__Debug swig_types[4] -#define SWIGTYPE_p_aruco__Dictionary swig_types[5] -#define SWIGTYPE_p_aruco__DictionaryBased swig_types[6] -#define SWIGTYPE_p_aruco__Marker swig_types[7] -#define SWIGTYPE_p_aruco__Marker3DInfo swig_types[8] -#define SWIGTYPE_p_aruco__MarkerDetector swig_types[9] -#define SWIGTYPE_p_aruco__MarkerDetector__Params swig_types[10] -#define SWIGTYPE_p_aruco__MarkerLabeler swig_types[11] -#define SWIGTYPE_p_aruco__MarkerMap swig_types[12] -#define SWIGTYPE_p_aruco__MarkerMapPoseTracker swig_types[13] -#define SWIGTYPE_p_aruco__MarkerPoseTracker swig_types[14] -#define SWIGTYPE_p_aruco__SVMMarkers swig_types[15] -#define SWIGTYPE_p_aruco__ScopeTimer swig_types[16] -#define SWIGTYPE_p_aruco__ScopedTimerEvents swig_types[17] -#define SWIGTYPE_p_aruco__Timer swig_types[18] -#define SWIGTYPE_p_char swig_types[19] -#define SWIGTYPE_p_cv__Point2f swig_types[20] -#define SWIGTYPE_p_cv__Point3f swig_types[21] -#define SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t swig_types[22] -#define SWIGTYPE_p_cv__Size swig_types[23] -#define SWIGTYPE_p_difference_type swig_types[24] -#define SWIGTYPE_p_double swig_types[25] -#define SWIGTYPE_p_int swig_types[26] -#define SWIGTYPE_p_p_PyObject swig_types[27] -#define SWIGTYPE_p_size_type swig_types[28] -#define SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t swig_types[29] -#define SWIGTYPE_p_std__allocatorT_aruco__Marker_t swig_types[30] -#define SWIGTYPE_p_std__allocatorT_cv__Point2f_t swig_types[31] -#define SWIGTYPE_p_std__allocatorT_int_t swig_types[32] -#define SWIGTYPE_p_std__chrono__high_resolution_clock__time_point swig_types[33] -#define SWIGTYPE_p_std__invalid_argument swig_types[34] -#define SWIGTYPE_p_std__istream swig_types[35] -#define SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t swig_types[36] -#define SWIGTYPE_p_std__ostream swig_types[37] -#define SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t swig_types[38] -#define SWIGTYPE_p_std__string swig_types[39] -#define SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t swig_types[40] -#define SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t swig_types[41] -#define SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t swig_types[42] -#define SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t swig_types[43] -#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[44] -#define SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t swig_types[45] -#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[46] -#define SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t swig_types[47] -#define SWIGTYPE_p_swig__SwigPyIterator swig_types[48] -#define SWIGTYPE_p_uint32_t swig_types[49] -#define SWIGTYPE_p_uint64_t swig_types[50] -#define SWIGTYPE_p_value_type swig_types[51] -#define SWIGTYPE_p_vectorT_aruco__Marker_t swig_types[52] -#define SWIGTYPE_p_vectorT_cv__Point3f_t swig_types[53] -#define SWIGTYPE_p_vectorT_cv__Point_t swig_types[54] -#define SWIGTYPE_p_vectorT_int_t swig_types[55] -static swig_type_info *swig_types[57]; -static swig_module_info swig_module = {swig_types, 56, 0, 0, 0, 0}; +#define SWIGTYPE_p_FractalMarker swig_types[0] +#define SWIGTYPE_p_FractalMarkerSet swig_types[1] +#define SWIGTYPE_p_FractalMarkerSet__CONF_TYPES swig_types[2] +#define SWIGTYPE_p_Marker swig_types[3] +#define SWIGTYPE_p_allocator_type swig_types[4] +#define SWIGTYPE_p_aruco__CameraParameters swig_types[5] +#define SWIGTYPE_p_aruco__CvDrawingUtils swig_types[6] +#define SWIGTYPE_p_aruco__Debug swig_types[7] +#define SWIGTYPE_p_aruco__Dictionary swig_types[8] +#define SWIGTYPE_p_aruco__FractalDetector swig_types[9] +#define SWIGTYPE_p_aruco__FractalMarker swig_types[10] +#define SWIGTYPE_p_aruco__FractalMarkerLabeler swig_types[11] +#define SWIGTYPE_p_aruco__FractalMarkerSet swig_types[12] +#define SWIGTYPE_p_aruco__FractalPoseTracker swig_types[13] +#define SWIGTYPE_p_aruco__Marker swig_types[14] +#define SWIGTYPE_p_aruco__Marker3DInfo swig_types[15] +#define SWIGTYPE_p_aruco__MarkerDetector swig_types[16] +#define SWIGTYPE_p_aruco__MarkerDetector__Params swig_types[17] +#define SWIGTYPE_p_aruco__MarkerLabeler swig_types[18] +#define SWIGTYPE_p_aruco__MarkerMap swig_types[19] +#define SWIGTYPE_p_aruco__MarkerMapPoseTracker swig_types[20] +#define SWIGTYPE_p_aruco__MarkerPoseTracker swig_types[21] +#define SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter swig_types[22] +#define SWIGTYPE_p_aruco__ScopeTimer swig_types[23] +#define SWIGTYPE_p_aruco__ScopedTimerEvents swig_types[24] +#define SWIGTYPE_p_aruco__Timer swig_types[25] +#define SWIGTYPE_p_char swig_types[26] +#define SWIGTYPE_p_cv__FileStorage swig_types[27] +#define SWIGTYPE_p_cv__KeyPoint swig_types[28] +#define SWIGTYPE_p_cv__Point2f swig_types[29] +#define SWIGTYPE_p_cv__Point3f swig_types[30] +#define SWIGTYPE_p_cv__PtrT_aruco__FractalMarkerLabeler_t swig_types[31] +#define SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t swig_types[32] +#define SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t swig_types[33] +#define SWIGTYPE_p_cv__Size swig_types[34] +#define SWIGTYPE_p_difference_type swig_types[35] +#define SWIGTYPE_p_double swig_types[36] +#define SWIGTYPE_p_float swig_types[37] +#define SWIGTYPE_p_int swig_types[38] +#define SWIGTYPE_p_p_PyObject swig_types[39] +#define SWIGTYPE_p_size_type swig_types[40] +#define SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t swig_types[41] +#define SWIGTYPE_p_std__allocatorT_aruco__Marker_t swig_types[42] +#define SWIGTYPE_p_std__allocatorT_cv__Point2f_t swig_types[43] +#define SWIGTYPE_p_std__allocatorT_int_t swig_types[44] +#define SWIGTYPE_p_std__chrono__high_resolution_clock__time_point swig_types[45] +#define SWIGTYPE_p_std__invalid_argument swig_types[46] +#define SWIGTYPE_p_std__istream swig_types[47] +#define SWIGTYPE_p_std__mapT_int_FractalMarker_t swig_types[48] +#define SWIGTYPE_p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t swig_types[49] +#define SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[50] +#define SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t swig_types[51] +#define SWIGTYPE_p_std__ostream swig_types[52] +#define SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t swig_types[53] +#define SWIGTYPE_p_std__string swig_types[54] +#define SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t swig_types[55] +#define SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t swig_types[56] +#define SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t swig_types[57] +#define SWIGTYPE_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t swig_types[58] +#define SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t swig_types[59] +#define SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t swig_types[60] +#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[61] +#define SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t swig_types[62] +#define SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t swig_types[63] +#define SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t swig_types[64] +#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[65] +#define SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t swig_types[66] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[67] +#define SWIGTYPE_p_uint32_t swig_types[68] +#define SWIGTYPE_p_uint64_t swig_types[69] +#define SWIGTYPE_p_value_type swig_types[70] +#define SWIGTYPE_p_vectorT_aruco__Marker_t swig_types[71] +#define SWIGTYPE_p_vectorT_cv__Point3f_t swig_types[72] +#define SWIGTYPE_p_vectorT_cv__Point_t swig_types[73] +#define SWIGTYPE_p_vectorT_int_t swig_types[74] +static swig_type_info *swig_types[76]; +static swig_module_info swig_module = {swig_types, 75, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5462,13 +5481,14 @@ SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,st #include +/* #define SWIG_FILE_WITH_INIT #include #include #include #include #include - #include + //#include #include //#include #include @@ -5479,7 +5499,30 @@ SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,st #include #include #include - +*/ + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include using namespace aruco; @@ -20374,6 +20417,28 @@ SWIGINTERN PyObject *_wrap_Marker_getArea(PyObject *SWIGUNUSEDPARM(self), PyObje } +SWIGINTERN PyObject *_wrap_Marker_getRadius(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_getRadius",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getRadius" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = (float)((aruco::Marker const *)arg1)->getRadius(); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Marker___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::Marker *arg1 = (aruco::Marker *) 0 ; @@ -20592,6 +20657,45 @@ SWIGINTERN PyObject *_wrap_Marker_get3DPoints(PyObject *self, PyObject *args) { } +SWIGINTERN PyObject *_wrap_Marker_getTransformMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker *arg1 = (aruco::Marker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker_getTransformMatrix",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getTransformMatrix" "', argument " "1"" of type '" "aruco::Marker const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker * >(argp1); + result = ((aruco::Marker const *)arg1)->getTransformMatrix(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Marker___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::Marker *arg1 = (aruco::Marker *) 0 ; @@ -21250,968 +21354,3434 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_2(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - aruco::CameraParameters arg4 ; - float arg5 ; - bool arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 ; - int res4 = 0 ; - float val5 ; - int ecode5 = 0 ; - bool val6 ; - int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; +SWIGINTERN PyObject *_wrap_MarkerDetector_detect(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); - { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); - } else { - aruco::CameraParameters * temp = reinterpret_cast< aruco::CameraParameters * >(argp4); - arg4 = *temp; - if (SWIG_IsNewObj(res4)) delete temp; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_0(self, args); + } } } - ecode5 = SWIG_AsVal_float(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerDetector_detect" "', argument " "5"" of type '" "float""'"); - } - arg5 = static_cast< float >(val5); - ecode6 = SWIG_AsVal_bool(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MarkerDetector_detect" "', argument " "6"" of type '" "bool""'"); - } - arg6 = static_cast< bool >(val6); - (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5,arg6); - resultobj = SWIG_Py_Void(); - { - + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_2(self, args); + } + } + } + } } - { - if (arg2 != NULL) - delete arg2; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_detect__SWIG_1(self, args); + } + } + } + } + } } - return resultobj; + fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_detect'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::detect(cv::Mat const &)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float,bool)\n" + " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - aruco::CameraParameters arg4 ; - float arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 ; - int res4 = 0 ; - float val5 ; - int ecode5 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; + aruco::MarkerDetector::Params result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); - { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); - } else { - aruco::CameraParameters * temp = reinterpret_cast< aruco::CameraParameters * >(argp4); - arg4 = *temp; - if (SWIG_IsNewObj(res4)) delete temp; - } - } - ecode5 = SWIG_AsVal_float(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerDetector_detect" "', argument " "5"" of type '" "float""'"); - } - arg5 = static_cast< float >(val5); - (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5); - resultobj = SWIG_Py_Void(); - { - - } - { - if (arg2 != NULL) - delete arg2; - } + result = ((aruco::MarkerDetector const *)arg1)->getParameters(); + resultobj = SWIG_NewPointerObj((new aruco::MarkerDetector::Params(static_cast< const aruco::MarkerDetector::Params& >(result))), SWIGTYPE_p_aruco__MarkerDetector__Params, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; - } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - aruco::CameraParameters arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 ; - int res4 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; + aruco::MarkerDetector::Params *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; + result = (aruco::MarkerDetector::Params *) &(arg1)->getParameters(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getParameters__SWIG_0(self, args); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getParameters__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getParameters'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::getParameters() const\n" + " aruco::MarkerDetector::getParameters()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::string arg2 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "aruco::CameraParameters""'"); - } else { - aruco::CameraParameters * temp = reinterpret_cast< aruco::CameraParameters * >(argp4); - arg4 = *temp; - if (SWIG_IsNewObj(res4)) delete temp; + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setDictionary(arg2,arg3); resultobj = SWIG_Py_Void(); - { - + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); { - if (arg2 != NULL) - delete arg2; + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } + (arg1)->setDictionary(arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; - } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - cv::Mat arg4 ; - cv::Mat arg5 ; - float arg6 ; - bool arg7 ; + int arg2 ; + float arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - cv::Mat *mat4 ; - cv::Mat *mat5 ; - float val6 ; - int ecode6 = 0 ; - bool val7 ; - int ecode7 = 0 ; + int val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; - } - { - mat5 = array_to_mat(obj4); - if (mat5 == NULL) - SWIG_fail; - arg5 = *mat5; - } - ecode6 = SWIG_AsVal_float(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MarkerDetector_detect" "', argument " "6"" of type '" "float""'"); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); } - arg6 = static_cast< float >(val6); - ecode7 = SWIG_AsVal_bool(obj6, &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MarkerDetector_detect" "', argument " "7"" of type '" "bool""'"); + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); } - arg7 = static_cast< bool >(val7); - (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + arg3 = static_cast< float >(val3); + (arg1)->setDictionary(arg2,arg3); resultobj = SWIG_Py_Void(); - { - - } - { - - } - { - - } - { - if (arg2 != NULL) - delete arg2; - } - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; - } - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - cv::Mat arg4 ; - cv::Mat arg5 ; - float arg6 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - cv::Mat *mat4 ; - cv::Mat *mat5 ; - float val6 ; - int ecode6 = 0 ; + int val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; - } - { - mat5 = array_to_mat(obj4); - if (mat5 == NULL) - SWIG_fail; - arg5 = *mat5; - } - ecode6 = SWIG_AsVal_float(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MarkerDetector_detect" "', argument " "6"" of type '" "float""'"); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); } - arg6 = static_cast< float >(val6); - (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5,arg6); + arg2 = static_cast< int >(val2); + (arg1)->setDictionary(arg2); resultobj = SWIG_Py_Void(); - { - - } - { - + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - { - + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_3(self, args); + } + } } - { - if (arg2 != NULL) - delete arg2; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_1(self, args); + } + } } - { - if (mat4 != NULL) - delete mat4; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_2(self, args); + } + } + } } - { - if (mat5 != NULL) - delete mat5; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerDetector_setDictionary__SWIG_0(self, args); + } + } + } } - return resultobj; + fail: - { - if (arg2 != NULL) - delete arg2; - } - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_setDictionary'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::setDictionary(std::string,float)\n" + " aruco::MarkerDetector::setDictionary(std::string)\n" + " aruco::MarkerDetector::setDictionary(int,float)\n" + " aruco::MarkerDetector::setDictionary(int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - cv::Mat arg4 ; - cv::Mat arg5 ; + uint32_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - cv::Mat *mat4 ; - cv::Mat *mat5 ; + void *argp2 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_getThresholdedImage",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint32_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); + } else { + uint32_t * temp = reinterpret_cast< uint32_t * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } } + result = (arg1)->getThresholdedImage(arg2); { - mat5 = array_to_mat(obj4); - if (mat5 == NULL) + PyObject* array = mat_to_array(result); + if (array == NULL) SWIG_fail; - arg5 = *mat5; - } - (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4,arg5); - resultobj = SWIG_Py_Void(); - { - - } - { - } - { + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif - } - { - if (arg2 != NULL) - delete arg2; - } - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; + resultobj = array; } return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; - } - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - cv::Mat arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - cv::Mat *mat4 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getThresholdedImage",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = (arg1)->getThresholdedImage(); { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) + PyObject* array = mat_to_array(result); + if (array == NULL) SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getThresholdedImage__SWIG_1(self, args); + } } - (arg1)->detect((cv::Mat const &)*arg2,*arg3,arg4); - resultobj = SWIG_Py_Void(); - { - + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_uint32_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerDetector_getThresholdedImage__SWIG_0(self, args); + } + } } - { - + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getThresholdedImage'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerDetector::getThresholdedImage(uint32_t)\n" + " aruco::MarkerDetector::getThresholdedImage()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + cv::Ptr< aruco::MarkerLabeler > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setMarkerLabeler",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); { - if (arg2 != NULL) - delete arg2; + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); + } else { + cv::Ptr< aruco::MarkerLabeler > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerLabeler > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } } - { - if (mat4 != NULL) - delete mat4; + (arg1)->setMarkerLabeler(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getMarkerLabeler",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = (arg1)->getMarkerLabeler(); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::MarkerCandidate,std::allocator< aruco::MarkerCandidate > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getCandidates",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getCandidates" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); } - { - if (mat4 != NULL) - delete mat4; + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = ((aruco::MarkerDetector const *)arg1)->getCandidates(); + resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_getImagePyramid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::vector< cv::Mat,std::allocator< cv::Mat > > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getImagePyramid",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getImagePyramid" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + result = (arg1)->getImagePyramid(); + resultobj = SWIG_NewPointerObj((new std::vector< cv::Mat,std::allocator< cv::Mat > >(static_cast< const std::vector< cv::Mat,std::allocator< cv::Mat > >& >(result))), SWIGTYPE_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerDetector_cornerUpsample(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > *arg2 = 0 ; + cv::Size arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_detect",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_cornerUpsample",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_cornerUpsample" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); } arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_cornerUpsample" "', argument " "2"" of type '" "std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > &""'"); } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp3); - (arg1)->detect((cv::Mat const &)*arg2,*arg3); - resultobj = SWIG_Py_Void(); - { - + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_cornerUpsample" "', argument " "2"" of type '" "std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > &""'"); } + arg2 = reinterpret_cast< std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > * >(argp2); { - if (arg2 != NULL) - delete arg2; + arg3 = *array_to_size(obj2); + if (&arg3 == NULL) + SWIG_fail; } + (arg1)->cornerUpsample(*arg2,arg3); + resultobj = SWIG_Py_Void(); return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; - } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_detect(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - Py_ssize_t ii; +SWIGINTERN PyObject *_wrap_MarkerDetector_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 7) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_toStream" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_0(self, args); - } - } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_10(self, args); - } - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + ((aruco::MarkerDetector const *)arg1)->toStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_fromStream" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + (arg1)->fromStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerDetector_setParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::MarkerDetector::Params *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setParameters",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); + } + arg2 = reinterpret_cast< aruco::MarkerDetector::Params * >(argp2); + (arg1)->setParameters((aruco::MarkerDetector::Params const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerDetector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerDetector, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary::DICT_TYPES arg1 ; + float arg2 ; + int val1 ; + int ecode1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); + } + arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = aruco::MarkerLabeler::create(arg1,arg2); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Dictionary::DICT_TYPES arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); + } + arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); + result = aruco::MarkerLabeler::create(arg1); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + std::string arg2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - if (argc == 4) { + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::MarkerLabeler::create(arg1,arg2); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + cv::Ptr< aruco::MarkerLabeler > result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::MarkerLabeler::create(arg1); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_create(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerLabeler_create__SWIG_1(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerLabeler_create__SWIG_3(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } if (_v) { { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_5(self, args); - } - } + return _wrap_MarkerLabeler_create__SWIG_0(self, args); } } } - if (argc == 4) { + if (argc == 2) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[3]) || PySequence_Check(argv[3]); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_9(self, args); - } - } + return _wrap_MarkerLabeler_create__SWIG_2(self, args); } } } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_2(self, args); - } - } - } - } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerLabeler_create'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES,float)\n" + " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES)\n" + " aruco::MarkerLabeler::create(std::string,std::string)\n" + " aruco::MarkerLabeler::create(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + cv::Mat *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + std::string *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerLabeler_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_detect" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[3]) || PySequence_Check(argv[3]); - } - if (_v) { - { - _v = is_array(argv[4]) || PySequence_Check(argv[4]); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_8(self, args); - } - } - } - } - } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_4(self, args); - } - } - } - } - } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_1(self, args); - } - } - } - } - } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[3]) || PySequence_Check(argv[3]); - } - if (_v) { - { - _v = is_array(argv[4]) || PySequence_Check(argv[4]); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_7(self, args); - } - } - } - } - } - } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); + } + arg5 = reinterpret_cast< std::string * >(argp5); + result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_getBestInputSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getBestInputSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getBestInputSize" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + result = (int)(arg1)->getBestInputSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getNSubdivisions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getNSubdivisions" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + result = (int)((aruco::MarkerLabeler const *)arg1)->getNSubdivisions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerLabeler_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getName" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + result = ((aruco::MarkerLabeler const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerLabeler",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerLabeler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerLabeler, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_FractalDetector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_FractalDetector")) SWIG_fail; + result = (aruco::FractalDetector *)new aruco::FractalDetector(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalDetector, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_setConfiguration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_setConfiguration",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_setConfiguration" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalDetector_setConfiguration" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setConfiguration(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_setConfiguration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_setConfiguration",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_setConfiguration" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalDetector_setConfiguration" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setConfiguration(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_setConfiguration(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalDetector_setConfiguration__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FractalDetector_setConfiguration__SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalDetector_setConfiguration'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::FractalDetector::setConfiguration(int)\n" + " aruco::FractalDetector::setConfiguration(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + aruco::CameraParameters *arg2 = 0 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalDetector_setParams",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_setParams" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalDetector_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalDetector_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalDetector_setParams" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setParams((aruco::CameraParameters const &)*arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_getConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + FractalMarkerSet result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getConfiguration",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getConfiguration" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + result = (arg1)->getConfiguration(); + resultobj = SWIG_NewPointerObj((new FractalMarkerSet(static_cast< const FractalMarkerSet& >(result))), SWIGTYPE_p_FractalMarkerSet, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + cv::Mat *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_detect",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_detect" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + result = (bool)(arg1)->detect((cv::Mat const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_poseEstimation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_poseEstimation",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_poseEstimation" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + result = (bool)(arg1)->poseEstimation(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getRvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getRvec" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + result = (arg1)->getRvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getTvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getTvec" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + result = (arg1)->getTvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_drawMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + cv::Mat *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_drawMarkers",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_drawMarkers" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + (arg1)->drawMarkers(*arg2); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_draw2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + cv::Mat *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_draw2d",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw2d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + (arg1)->draw2d(*arg2); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_draw3d__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + cv::Mat *arg2 = 0 ; + bool arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + bool val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalDetector_draw3d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalDetector_draw3d" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalDetector_draw3d" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + (arg1)->draw3d(*arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_draw3d__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + cv::Mat *arg2 = 0 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalDetector_draw3d",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalDetector_draw3d" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + (arg1)->draw3d(*arg2,arg3); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_draw3d__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + cv::Mat *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_draw3d",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + (arg1)->draw3d(*arg2); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_draw3d(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + return _wrap_FractalDetector_draw3d__SWIG_2(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalDetector_draw3d__SWIG_1(self, args); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalDetector_draw3d__SWIG_0(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalDetector_draw3d'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::FractalDetector::draw3d(cv::Mat &,bool,bool)\n" + " aruco::FractalDetector::draw3d(cv::Mat &,bool)\n" + " aruco::FractalDetector::draw3d(cv::Mat &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_draw3dCube(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + cv::Mat *arg2 = 0 ; + FractalMarker arg3 ; + aruco::CameraParameters *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar *data_ptr2 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalDetector_draw3dCube",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3dCube" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FractalMarker, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalDetector_draw3dCube" "', argument " "3"" of type '" "FractalMarker""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalDetector_draw3dCube" "', argument " "3"" of type '" "FractalMarker""'"); + } else { + FractalMarker * temp = reinterpret_cast< FractalMarker * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalDetector_draw3dCube" "', argument " "4"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalDetector_draw3dCube" "', argument " "4"" of type '" "aruco::CameraParameters const &""'"); + } + arg4 = reinterpret_cast< aruco::CameraParameters * >(argp4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FractalDetector_draw3dCube" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->draw3dCube(*arg2,arg3,(aruco::CameraParameters const &)*arg4,arg5); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; + } + } + { + if (arg2 != NULL) + delete arg2; + } + return resultobj; +fail: + { + if (arg2 != NULL) + delete arg2; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalDetector_getMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getMarkers",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getMarkers" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + result = (arg1)->getMarkers(); + resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_FractalDetector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalDetector",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalDetector" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); + } + arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *FractalDetector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalDetector, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Marker3DInfo_points_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + std::vector< cv::Point3f,std::allocator< cv::Point3f > > *arg2 = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_points_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_points_set" "', argument " "2"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > > *""'"); + } + arg2 = reinterpret_cast< std::vector< cv::Point3f,std::allocator< cv::Point3f > > * >(argp2); + if (arg1) (arg1)->points = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_points_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< cv::Point3f,std::allocator< cv::Point3f > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_points_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *)& ((arg1)->points); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_id_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_id_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->id = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_id_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = (int) ((arg1)->id); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Marker3DInfo")) SWIG_fail; + result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + aruco::Marker3DInfo *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_Marker3DInfo",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Marker3DInfo" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Marker3DInfo(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_Marker3DInfo__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Marker3DInfo__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Marker3DInfo'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::Marker3DInfo::Marker3DInfo()\n" + " aruco::Marker3DInfo::Marker3DInfo(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::Marker3DInfo *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo___eq__" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); + } + arg2 = reinterpret_cast< aruco::Marker3DInfo * >(argp2); + result = (bool)(arg1)->operator ==((aruco::Marker3DInfo const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_getMarkerSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + float result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_getMarkerSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_getMarkerSize" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = (float)((aruco::Marker3DInfo const *)arg1)->getMarkerSize(); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Point3f result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_at",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_at" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_at" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + result = ((aruco::Marker3DInfo const *)arg1)->at(arg2); + resultobj = SWIG_NewPointerObj((new cv::Point3f(static_cast< const cv::Point3f& >(result))), SWIGTYPE_p_cv__Point3f, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + cv::Point3f *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_push_back" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point3f, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); + } + arg2 = reinterpret_cast< cv::Point3f * >(argp2); + (arg1)->push_back((cv::Point3f const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + size_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_size" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + result = ((aruco::Marker3DInfo const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_toStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + (arg1)->toStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Marker3DInfo_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_fromStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + (arg1)->fromStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Marker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Marker3DInfo",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Marker3DInfo" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + } + arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Marker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker3DInfo, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerMap")) SWIG_fail; + result = (aruco::MarkerMap *)new aruco::MarkerMap(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::MarkerMap *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerMap",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerMap" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (aruco::MarkerMap *)new aruco::MarkerMap(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MarkerMap(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_MarkerMap__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MarkerMap__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerMap'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMap::MarkerMap()\n" + " aruco::MarkerMap::MarkerMap(std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInMeters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInMeters(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInPixels",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInPixels" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInPixels(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_convertToMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::MarkerMap result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_convertToMeters",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_convertToMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_convertToMeters" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = ((aruco::MarkerMap const *)arg1)->convertToMeters(arg2); + resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + vector< aruco::Marker > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int,std::allocator< int > > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndices",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndices" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_aruco__Marker_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); + } + arg2 = reinterpret_cast< vector< aruco::Marker > * >(argp2); + result = ((aruco::MarkerMap const *)arg1)->getIndices((vector< aruco::Marker > const &)*arg2); + resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getMarker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + aruco::Marker3DInfo *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getMarker3DInfo",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (aruco::Marker3DInfo *) &((aruco::MarkerMap const *)arg1)->getMarker3DInfo(arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIndexOfMarkerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndexOfMarkerId",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)((aruco::MarkerMap const *)arg1)->getIndexOfMarkerId(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + vector< int > *arg2 = 0 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMap_getIdList",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + arg2 = reinterpret_cast< vector< int > * >(argp2); + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_getIdList" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + ((aruco::MarkerMap const *)arg1)->getIdList(*arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + vector< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIdList",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + } + arg2 = reinterpret_cast< vector< int > * >(argp2); + ((aruco::MarkerMap const *)arg1)->getIdList(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getIdList(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerMap_getIdList__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerMap_getIdList__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getIdList'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMap::getIdList(vector< int > &,bool) const\n" + " aruco::MarkerMap::getIdList(vector< int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getImage",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getImage" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = ((aruco::MarkerMap const *)arg1)->getImage(arg2); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getImage",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = ((aruco::MarkerMap const *)arg1)->getImage(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getImage(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MarkerMap_getImage__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerMap_getImage__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getImage'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMap::getImage(float) const\n" + " aruco::MarkerMap::getImage() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_saveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_saveToFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_saveToFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_saveToFile" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->saveToFile(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_readFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_readFromFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_readFromFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_readFromFile" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->readFromFile(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_calculateExtrinsics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; + float arg3 ; + cv::Mat arg4 ; + cv::Mat arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + float val3 ; + int ecode3 = 0 ; + cv::Mat *mat4 ; + cv::Mat *mat5 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + std::pair< cv::Mat,cv::Mat > result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerMap_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res2 = swig::asptr(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg2 = ptr; + } + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + { + mat4 = array_to_mat(obj3); + if (mat4 == NULL) + SWIG_fail; + arg4 = *mat4; + } + { + mat5 = array_to_mat(obj4); + if (mat5 == NULL) + SWIG_fail; + arg5 = *mat5; + } + result = (arg1)->calculateExtrinsics((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2,arg3,arg4,arg5); + resultobj = SWIG_NewPointerObj((new std::pair< cv::Mat,cv::Mat >(static_cast< const std::pair< cv::Mat,cv::Mat >& >(result))), SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t, SWIG_POINTER_OWN | 0 ); + { + + } + { + + } + if (SWIG_IsNewObj(res2)) delete arg2; + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + { + if (mat4 != NULL) + delete mat4; + } + { + if (mat5 != NULL) + delete mat5; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_getDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getDictionary",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getDictionary" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = ((aruco::MarkerMap const *)arg1)->getDictionary(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_setDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_setDictionary",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_setDictionary" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_setDictionary" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setDictionary(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_mInfoType_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_set" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_mInfoType_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->mInfoType = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_mInfoType_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_get" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = (int) ((arg1)->mInfoType); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_toStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + (arg1)->toStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMap_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_fromStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + (arg1)->fromStream(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMap",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMap" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MarkerMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMap, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + aruco::Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + float arg4 ; + float arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; + float val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + arg2 = reinterpret_cast< aruco::Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + ecode5 = SWIG_AsVal_float(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "5"" of type '" "float""'"); + } + arg5 = static_cast< float >(val5); + result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + aruco::Marker *arg2 = 0 ; + aruco::CameraParameters *arg3 = 0 ; + float arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + } + arg2 = reinterpret_cast< aruco::Marker * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + } + arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 6) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); _v = SWIG_CheckState(res); if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - { - int res = SWIG_AsVal_float(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_3(self, args); - } - } + return _wrap_MarkerPoseTracker_estimatePose__SWIG_1(self, args); } } } } } - if (argc == 7) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); _v = SWIG_CheckState(res); if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); _v = SWIG_CheckState(res); if (_v) { { - _v = is_array(argv[3]) || PySequence_Check(argv[3]); + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { { - _v = is_array(argv[4]) || PySequence_Check(argv[4]); + int res = SWIG_AsVal_float(argv[4], NULL); + _v = SWIG_CheckState(res); } if (_v) { - { - int res = SWIG_AsVal_float(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_6(self, args); - } - } + return _wrap_MarkerPoseTracker_estimatePose__SWIG_0(self, args); } } } @@ -22220,173 +24790,158 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_detect(PyObject *self, PyObject *args) } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_detect'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerPoseTracker_estimatePose'.\n" " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::detect(cv::Mat const &)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float,bool)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,aruco::CameraParameters,float,bool)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,aruco::CameraParameters,float)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,aruco::CameraParameters)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat,cv::Mat,float,bool)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat,cv::Mat,float)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat,cv::Mat)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &,cv::Mat)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,std::vector< aruco::Marker,std::allocator< aruco::Marker > > &)\n"); + " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float,float)\n" + " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - aruco::MarkerDetector::Params result; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRTMatrix",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + result = ((aruco::MarkerPoseTracker const *)arg1)->getRTMatrix(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = ((aruco::MarkerDetector const *)arg1)->getParameters(); - resultobj = SWIG_NewPointerObj((new aruco::MarkerDetector::Params(static_cast< const aruco::MarkerDetector::Params& >(result))), SWIGTYPE_p_aruco__MarkerDetector__Params, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - aruco::MarkerDetector::Params *result = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + result = ((aruco::MarkerPoseTracker const *)arg1)->getRvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (aruco::MarkerDetector::Params *) &(arg1)->getParameters(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getParameters__SWIG_0(self, args); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getParameters__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getParameters'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::getParameters() const\n" - " aruco::MarkerDetector::getParameters()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::string arg2 ; - float arg3 ; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - float val3 ; - int ecode3 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getTvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + result = ((aruco::MarkerPoseTracker const *)arg1)->getTvec(); { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setDictionary(arg2,arg3); - resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerPoseTracker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerPoseTracker")) SWIG_fail; + result = (aruco::MarkerPoseTracker *)new aruco::MarkerPoseTracker(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::string arg2 ; + aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerPoseTracker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerPoseTracker" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); } - (arg1)->setDictionary(arg2); + arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); + delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -22394,38 +24949,73 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MarkerPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - int arg2 ; - float arg3 ; + aruco::MarkerMapPoseTracker *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_MarkerMapPoseTracker")) SWIG_fail; + result = (aruco::MarkerMapPoseTracker *)new aruco::MarkerMapPoseTracker(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::CameraParameters *arg2 = 0 ; + aruco::MarkerMap *arg3 = 0 ; + float arg4 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - float val3 ; - int ecode3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + float val4 ; + int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "4"" of type '" "float""'"); } - arg3 = static_cast< float >(val3); - (arg1)->setDictionary(arg2,arg3); + arg4 = static_cast< float >(val4); + (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3,arg4); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -22433,29 +25023,44 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_2(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - int arg2 ; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::CameraParameters *arg2 = 0 ; + aruco::MarkerMap *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - (arg1)->setDictionary(arg2); + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + } + arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); + (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -22463,130 +25068,164 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_3(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[5] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { + for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_3(self, args); - } - } - } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[2], NULL); - _v = SWIG_CheckState(res); - } if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_2(self, args); + return _wrap_MarkerMapPoseTracker_setParams__SWIG_1(self, args); } } } } - if (argc == 3) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_float(argv[2], NULL); - _v = SWIG_CheckState(res); - } + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_0(self, args); + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MarkerMapPoseTracker_setParams__SWIG_0(self, args); + } } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_setDictionary'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::setDictionary(std::string,float)\n" - " aruco::MarkerDetector::setDictionary(std::string)\n" - " aruco::MarkerDetector::setDictionary(int,float)\n" - " aruco::MarkerDetector::setDictionary(int)\n"); - return 0; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMapPoseTracker_setParams'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &,float)\n" + " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_isValid",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_isValid" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = (bool)((aruco::MarkerMapPoseTracker const *)arg1)->isValid(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_reset",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_reset" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + (arg1)->reset(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_estimatePose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - uint32_t arg2 ; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; + int res2 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - cv::Mat result; + bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_getThresholdedImage",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMapPoseTracker_estimatePose",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint32_t, 0 | 0); + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res2 = swig::asptr(obj1, &ptr); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); - } else { - uint32_t * temp = reinterpret_cast< uint32_t * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg2 = ptr; } - result = (arg1)->getThresholdedImage(arg2); + result = (bool)(arg1)->estimatePose((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + cv::Mat result; + + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRTMatrix",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRTMatrix(); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -22611,21 +25250,21 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getThresholdedImage",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (arg1)->getThresholdedImage(); + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRvec(); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -22650,346 +25289,285 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getThresholdedImage__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_uint32_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getThresholdedImage__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getThresholdedImage'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::getThresholdedImage(uint32_t)\n" - " aruco::MarkerDetector::getThresholdedImage()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getNhresholdedImages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - size_t result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getNhresholdedImages",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getNhresholdedImages" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = ((aruco::MarkerDetector const *)arg1)->getNhresholdedImages(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Ptr< aruco::MarkerLabeler > arg2 ; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setMarkerLabeler",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getTvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + result = ((aruco::MarkerMapPoseTracker const *)arg1)->getTvec(); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); - } else { - cv::Ptr< aruco::MarkerLabeler > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerLabeler > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - (arg1)->setMarkerLabeler(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getMarkerLabeler",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (arg1)->getMarkerLabeler(); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_getCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setMaxTrackingDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + float arg2 ; + float arg3 ; void *argp1 = 0 ; int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; - SwigValueWrapper< std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > > result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getCandidates",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setMaxTrackingDifference",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getCandidates" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = ((aruco::MarkerDetector const *)arg1)->getCandidates(); - resultobj = SWIG_NewPointerObj((new std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > >(static_cast< const std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setMaxTrackingDifference(arg2,arg3); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_warp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - cv::Mat *arg3 = 0 ; - cv::Size arg4 ; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > arg5 ; + aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - uchar *data_ptr2 ; - uchar *data_ptr3 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_warp",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMapPoseTracker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_warp" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - { - arg3 = array_to_mat(obj2); - if (arg3 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr3 = arg3->data; - } - { - arg4 = *array_to_size(obj3); - if (&arg4 == NULL) - SWIG_fail; - } - { - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; - int res = swig::asptr(obj4, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_warp" "', argument " "5"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > >""'"); - } - arg5 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (bool)(arg1)->warp(*arg2,*arg3,arg4,arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - // check if the underlying data changed - if (data_ptr3 != arg3->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg3->rows, arg3->cols, arg3->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - { - if (arg3 != NULL) - delete arg3; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMapPoseTracker" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); } + arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; - } - { - if (arg3 != NULL) - delete arg3; - } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MarkerMapPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_PicoFlann_KeyPointAdapter___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::ostream *arg2 = 0 ; + aruco::PicoFlann_KeyPointAdapter *arg1 = (aruco::PicoFlann_KeyPointAdapter *) 0 ; + cv::KeyPoint *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + float result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:PicoFlann_KeyPointAdapter___call__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_toStream" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "1"" of type '" "aruco::PicoFlann_KeyPointAdapter const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + arg1 = reinterpret_cast< aruco::PicoFlann_KeyPointAdapter * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__KeyPoint, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::KeyPoint const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::KeyPoint const &""'"); } - arg2 = reinterpret_cast< std::ostream * >(argp2); - ((aruco::MarkerDetector const *)arg1)->toStream(*arg2); - resultobj = SWIG_Py_Void(); + arg2 = reinterpret_cast< cv::KeyPoint * >(argp2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (float)((aruco::PicoFlann_KeyPointAdapter const *)arg1)->operator ()((cv::KeyPoint const &)*arg2,arg3); + resultobj = SWIG_From_float(static_cast< float >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PicoFlann_KeyPointAdapter___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::istream *arg2 = 0 ; + aruco::PicoFlann_KeyPointAdapter *arg1 = (aruco::PicoFlann_KeyPointAdapter *) 0 ; + cv::Point2f *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + float result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:PicoFlann_KeyPointAdapter___call__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_fromStream" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "1"" of type '" "aruco::PicoFlann_KeyPointAdapter const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + arg1 = reinterpret_cast< aruco::PicoFlann_KeyPointAdapter * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::Point2f const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::Point2f const &""'"); } - arg2 = reinterpret_cast< std::istream * >(argp2); - (arg1)->fromStream(*arg2); - resultobj = SWIG_Py_Void(); + arg2 = reinterpret_cast< cv::Point2f * >(argp2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (float)((aruco::PicoFlann_KeyPointAdapter const *)arg1)->operator ()((cv::Point2f const &)*arg2,arg3); + resultobj = SWIG_From_float(static_cast< float >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerDetector_setParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PicoFlann_KeyPointAdapter___call__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__KeyPoint, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_PicoFlann_KeyPointAdapter___call____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Point2f, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_PicoFlann_KeyPointAdapter___call____SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PicoFlann_KeyPointAdapter___call__'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::PicoFlann_KeyPointAdapter::operator ()(cv::KeyPoint const &,int) const\n" + " aruco::PicoFlann_KeyPointAdapter::operator ()(cv::Point2f const &,int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_PicoFlann_KeyPointAdapter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - aruco::MarkerDetector::Params *arg2 = 0 ; + aruco::PicoFlann_KeyPointAdapter *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_PicoFlann_KeyPointAdapter")) SWIG_fail; + result = (aruco::PicoFlann_KeyPointAdapter *)new aruco::PicoFlann_KeyPointAdapter(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_PicoFlann_KeyPointAdapter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::PicoFlann_KeyPointAdapter *arg1 = (aruco::PicoFlann_KeyPointAdapter *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setParameters",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_PicoFlann_KeyPointAdapter",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PicoFlann_KeyPointAdapter" "', argument " "1"" of type '" "aruco::PicoFlann_KeyPointAdapter *""'"); } - arg2 = reinterpret_cast< aruco::MarkerDetector::Params * >(argp2); - (arg1)->setParameters((aruco::MarkerDetector::Params const &)*arg2); + arg1 = reinterpret_cast< aruco::PicoFlann_KeyPointAdapter * >(argp1); + delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -22997,254 +25575,408 @@ SWIGINTERN PyObject *_wrap_MarkerDetector_setParameters(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *MarkerDetector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *PicoFlann_KeyPointAdapter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerDetector, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_FractalPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Dictionary::DICT_TYPES arg1 ; - float arg2 ; - int val1 ; - int ecode1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; + aruco::FractalPoseTracker *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); - } - arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = aruco::MarkerLabeler::create(arg1,arg2); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)":new_FractalPoseTracker")) SWIG_fail; + result = (aruco::FractalPoseTracker *)new aruco::FractalPoseTracker(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalPoseTracker, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Dictionary::DICT_TYPES arg1 ; - int val1 ; - int ecode1 = 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + aruco::CameraParameters *arg2 = 0 ; + FractalMarkerSet *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); - } - arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); - result = aruco::MarkerLabeler::create(arg1); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_setParams",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_setParams" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); + } + arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FractalMarkerSet, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_setParams" "', argument " "3"" of type '" "FractalMarkerSet const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_setParams" "', argument " "3"" of type '" "FractalMarkerSet const &""'"); + } + arg3 = reinterpret_cast< FractalMarkerSet * >(argp3); + (arg1)->setParams((aruco::CameraParameters const &)*arg2,(FractalMarkerSet const &)*arg3); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalInnerPose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - std::string arg1 ; - std::string arg2 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + cv::Ptr< aruco::MarkerDetector > arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + int res3 = SWIG_OLDOBJ ; + bool val4 ; + int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalPoseTracker_fractalInnerPose",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } else { + cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; } { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "std::string""'"); + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg3 = ptr; } - result = aruco::MarkerLabeler::create(arg1,arg2); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + result = (bool)(arg1)->fractalInnerPose(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg3,arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: + if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalInnerPose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - std::string arg1 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + cv::Ptr< aruco::MarkerDetector > arg2 ; + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + int res3 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_fractalInnerPose",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } else { + cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; } - result = aruco::MarkerLabeler::create(arg1); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); + { + std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + } + arg3 = ptr; + } + result = (bool)(arg1)->fractalInnerPose(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: + if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } -SWIGINTERN PyObject *_wrap_MarkerLabeler_create(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalInnerPose(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[5] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { + for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerLabeler_create__SWIG_1(self, args); - } - } - if (argc == 1) { + if (argc == 3) { int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MarkerLabeler_create__SWIG_3(self, args); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } if (_v) { - return _wrap_MarkerLabeler_create__SWIG_0(self, args); + int res = swig::asptr(argv[2], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FractalPoseTracker_fractalInnerPose__SWIG_1(self, args); + } } } } - if (argc == 2) { + if (argc == 4) { int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MarkerLabeler_create__SWIG_2(self, args); + int res = swig::asptr(argv[2], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalPoseTracker_fractalInnerPose__SWIG_0(self, args); + } + } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerLabeler_create'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_fractalInnerPose'.\n" " Possible C/C++ prototypes are:\n" - " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES,float)\n" - " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES)\n" - " aruco::MarkerLabeler::create(std::string,std::string)\n" - " aruco::MarkerLabeler::create(std::string)\n"); + " aruco::FractalPoseTracker::fractalInnerPose(cv::Ptr< aruco::MarkerDetector > const,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &,bool)\n" + " aruco::FractalPoseTracker::fractalInnerPose(cv::Ptr< aruco::MarkerDetector > const,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MarkerLabeler_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_ROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - cv::Mat *arg2 = 0 ; - int *arg3 = 0 ; - int *arg4 = 0 ; - std::string *arg5 = 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + SwigValueWrapper< std::vector< cv::Mat,std::allocator< cv::Mat > > > arg2 ; + cv::Mat *arg3 = 0 ; + std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg4 = 0 ; + cv::Point2f *arg5 = 0 ; + float *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 ; + int res2 = 0 ; + uchar *data_ptr3 ; void *argp4 = 0 ; int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FractalPoseTracker_ROI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_ROI" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_ROI" "', argument " "2"" of type '" "std::vector< cv::Mat,std::allocator< cv::Mat > > const""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "2"" of type '" "std::vector< cv::Mat,std::allocator< cv::Mat > > const""'"); + } else { + std::vector< cv::Mat,std::allocator< cv::Mat > > * temp = reinterpret_cast< std::vector< cv::Mat,std::allocator< cv::Mat > > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + { + arg3 = array_to_mat(obj2); + if (arg3 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr3 = arg3->data; + } + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_ROI" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > &""'"); + } + arg4 = reinterpret_cast< std::vector< cv::Point2f,std::allocator< cv::Point2f > > * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cv__Point2f, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_ROI" "', argument " "5"" of type '" "cv::Point2f &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "5"" of type '" "cv::Point2f &""'"); + } + arg5 = reinterpret_cast< cv::Point2f * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_float, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FractalPoseTracker_ROI" "', argument " "6"" of type '" "float &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "6"" of type '" "float &""'"); + } + arg6 = reinterpret_cast< float * >(argp6); + (arg1)->ROI(arg2,*arg3,*arg4,*arg5,*arg6); + resultobj = SWIG_Py_Void(); + { + // check if the underlying data changed + if (data_ptr3 != arg3->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg3->rows, arg3->cols, arg3->type()); + SWIG_fail; + } + } + { + if (arg3 != NULL) + delete arg3; + } + return resultobj; +fail: + { + if (arg3 != NULL) + delete arg3; + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *arg3 = 0 ; + bool arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; - bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerLabeler_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalPoseTracker_assignClass",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_detect" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_assignClass" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); { arg2 = array_to_mat(obj1); if (arg2 == NULL) SWIG_fail; } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); - } - arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); } - arg5 = reinterpret_cast< std::string * >(argp5); - result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg3 = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalPoseTracker_assignClass" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FractalPoseTracker_assignClass" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->assignClass((cv::Mat const &)*arg2,*arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); { } @@ -23262,301 +25994,808 @@ SWIGINTERN PyObject *_wrap_MarkerLabeler_detect(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MarkerLabeler_getBestInputSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *arg3 = 0 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; PyObject * obj0 = 0 ; - int result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getBestInputSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalPoseTracker_assignClass",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getBestInputSize" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_assignClass" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - result = (int)(arg1)->getBestInputSize(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getNSubdivisions",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getNSubdivisions" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - result = (int)((aruco::MarkerLabeler const *)arg1)->getNSubdivisions(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getName" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); + } + arg3 = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp3); + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalPoseTracker_assignClass" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + (arg1)->assignClass((cv::Mat const &)*arg2,*arg3,arg4); + resultobj = SWIG_Py_Void(); + { + + } + { + if (arg2 != NULL) + delete arg2; } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - result = ((aruco::MarkerLabeler const *)arg1)->getName(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: + { + if (arg2 != NULL) + delete arg2; + } return NULL; } -SWIGINTERN PyObject *_wrap_delete_MarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + cv::Mat *arg2 = 0 ; + std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerLabeler",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_assignClass",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_assignClass" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - delete arg1; + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); + } + arg3 = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp3); + (arg1)->assignClass((cv::Mat const &)*arg2,*arg3); resultobj = SWIG_Py_Void(); + { + + } + { + if (arg2 != NULL) + delete arg2; + } return resultobj; fail: + { + if (arg2 != NULL) + delete arg2; + } return NULL; } -SWIGINTERN PyObject *MarkerLabeler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerLabeler, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_Marker3DInfo_points_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - std::vector< cv::Point3f,std::allocator< cv::Point3f > > *arg2 = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; +SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_points_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 5) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_points_set" "', argument " "2"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > > *""'"); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FractalPoseTracker_assignClass__SWIG_2(self, args); + } + } + } } - arg2 = reinterpret_cast< std::vector< cv::Point3f,std::allocator< cv::Point3f > > * >(argp2); - if (arg1) (arg1)->points = *arg2; - resultobj = SWIG_Py_Void(); - return resultobj; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalPoseTracker_assignClass__SWIG_1(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalPoseTracker_assignClass__SWIG_0(self, args); + } + } + } + } + } + } + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_assignClass'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::FractalPoseTracker::assignClass(cv::Mat const &,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &,bool,int)\n" + " aruco::FractalPoseTracker::assignClass(cv::Mat const &,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &,bool)\n" + " aruco::FractalPoseTracker::assignClass(cv::Mat const &,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_points_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + int arg2 ; + SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; + SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; + uint32_t arg5 ; + float arg6 ; + float arg7 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + void *argp5 ; + int res5 = 0 ; + float val6 ; + int ecode6 = 0 ; + float val7 ; + int ecode7 = 0 ; PyObject * obj0 = 0 ; - std::vector< cv::Point3f,std::allocator< cv::Point3f > > *result = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_points_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } else { + std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } else { + std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + { + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_uint32_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); + } else { + uint32_t * temp = reinterpret_cast< uint32_t * >(argp5); + arg5 = *temp; + if (SWIG_IsNewObj(res5)) delete temp; + } + } + ecode6 = SWIG_AsVal_float(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "6"" of type '" "float""'"); + } + arg6 = static_cast< float >(val6); + ecode7 = SWIG_AsVal_float(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "7"" of type '" "float""'"); + } + arg7 = static_cast< float >(val7); + result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4,arg5,arg6,arg7); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *)& ((arg1)->points); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; int arg2 ; + SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; + SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; + uint32_t arg5 ; + float arg6 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + void *argp5 ; + int res5 = 0 ; + float val6 ; + int ecode6 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_id_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_id_set" "', argument " "2"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - if (arg1) (arg1)->id = arg2; - resultobj = SWIG_Py_Void(); + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } else { + std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } else { + std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + { + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_uint32_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); + } else { + uint32_t * temp = reinterpret_cast< uint32_t * >(argp5); + arg5 = *temp; + if (SWIG_IsNewObj(res5)) delete temp; + } + } + ecode6 = SWIG_AsVal_float(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "6"" of type '" "float""'"); + } + arg6 = static_cast< float >(val6); + result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4,arg5,arg6); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + int arg2 ; + SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; + SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; + uint32_t arg5 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + void *argp5 ; + int res5 = 0 ; PyObject * obj0 = 0 ; - int result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_id_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } else { + std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } else { + std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + { + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_uint32_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); + } else { + uint32_t * temp = reinterpret_cast< uint32_t * >(argp5); + arg5 = *temp; + if (SWIG_IsNewObj(res5)) delete temp; + } + } + result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4,arg5); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = (int) ((arg1)->id); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Marker3DInfo")) SWIG_fail; - result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + int arg2 ; + SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; + SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; PyObject * obj0 = 0 ; - aruco::Marker3DInfo *result = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:new_Marker3DInfo",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Marker3DInfo" "', argument " "1"" of type '" "int""'"); + if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); } - arg1 = static_cast< int >(val1); - result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); + arg2 = static_cast< int >(val2); + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); + } else { + std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); + } else { + std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Marker3DInfo(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[8] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { + for (ii = 0; (ii < 7) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 0) { - return _wrap_new_Marker3DInfo__SWIG_0(self, args); + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_3(self, args); + } + } + } + } } - if (argc == 1) { + if (argc == 5) { int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_uint32_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_2(self, args); + } + } + } + } } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Marker3DInfo__SWIG_1(self, args); + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_uint32_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_1(self, args); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_uint32_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_0(self, args); + } + } + } + } + } + } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Marker3DInfo'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_fractal_solve_ransac'.\n" " Possible C/C++ prototypes are:\n" - " aruco::Marker3DInfo::Marker3DInfo()\n" - " aruco::Marker3DInfo::Marker3DInfo(int)\n"); + " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >,uint32_t,float,float)\n" + " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >,uint32_t,float)\n" + " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >,uint32_t)\n" + " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Marker3DInfo___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - aruco::Marker3DInfo *arg2 = 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + cv::Ptr< aruco::MarkerDetector > arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_fractalRefinement",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo___eq__" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } else { + cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } } - arg2 = reinterpret_cast< aruco::Marker3DInfo * >(argp2); - result = (bool)(arg1)->operator ==((aruco::Marker3DInfo const &)*arg2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (bool)(arg1)->fractalRefinement(arg2,arg3); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: @@ -23564,193 +26803,234 @@ SWIGINTERN PyObject *_wrap_Marker3DInfo___eq__(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Marker3DInfo_getMarkerSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; + cv::Ptr< aruco::MarkerDetector > arg2 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - float result; + PyObject * obj1 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_getMarkerSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalPoseTracker_fractalRefinement",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_getMarkerSize" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = (float)((aruco::Marker3DInfo const *)arg1)->getMarkerSize(); - resultobj = SWIG_From_float(static_cast< float >(result)); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); + } else { + cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (bool)(arg1)->fractalRefinement(arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - size_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Point3f result; +SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalRefinement(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_at",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_at" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_at" "', argument " "2"" of type '" "size_t""'"); - } - arg2 = static_cast< size_t >(val2); - result = ((aruco::Marker3DInfo const *)arg1)->at(arg2); - resultobj = SWIG_NewPointerObj((new cv::Point3f(static_cast< const cv::Point3f& >(result))), SWIGTYPE_p_cv__Point3f, SWIG_POINTER_OWN | 0 ); - return resultobj; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FractalPoseTracker_fractalRefinement__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalPoseTracker_fractalRefinement__SWIG_0(self, args); + } + } + } + } + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_fractalRefinement'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::FractalPoseTracker::fractalRefinement(cv::Ptr< aruco::MarkerDetector > const,int)\n" + " aruco::FractalPoseTracker::fractalRefinement(cv::Ptr< aruco::MarkerDetector > const)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - cv::Point3f *arg2 = 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_push_back",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_getRvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_push_back" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point3f, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::FractalPoseTracker const *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + result = ((aruco::FractalPoseTracker const *)arg1)->getRvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg2 = reinterpret_cast< cv::Point3f * >(argp2); - (arg1)->push_back((cv::Point3f const &)*arg2); - resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - size_t result; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_getTvec",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_size" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::FractalPoseTracker const *""'"); + } + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + result = ((aruco::FractalPoseTracker const *)arg1)->getTvec(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = ((aruco::Marker3DInfo const *)arg1)->size(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_getInner3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - std::ostream *arg2 = 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + SwigValueWrapper< std::vector< cv::Point3f,std::allocator< cv::Point3f > > > result; - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_getInner3d",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_toStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_getInner3d" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - arg2 = reinterpret_cast< std::ostream * >(argp2); - (arg1)->toStream(*arg2); - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + result = (arg1)->getInner3d(); + resultobj = SWIG_NewPointerObj((new std::vector< cv::Point3f,std::allocator< cv::Point3f > >(static_cast< const std::vector< cv::Point3f,std::allocator< cv::Point3f > >& >(result))), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Marker3DInfo_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalPoseTracker_isPoseValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - std::istream *arg2 = 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_isPoseValid",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_fromStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_isPoseValid" "', argument " "1"" of type '" "aruco::FractalPoseTracker const *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - (arg1)->fromStream(*arg2); - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); + result = (bool)((aruco::FractalPoseTracker const *)arg1)->isPoseValid(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_Marker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_FractalPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; + aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Marker3DInfo",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalPoseTracker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Marker3DInfo" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalPoseTracker" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); + arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; @@ -23759,51 +27039,68 @@ SWIGINTERN PyObject *_wrap_delete_Marker3DInfo(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *Marker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FractalPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker3DInfo, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalPoseTracker, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *result = 0 ; + std::string arg1 ; + PyObject * obj0 = 0 ; + cv::Ptr< aruco::FractalMarkerLabeler > result; - if (!PyArg_ParseTuple(args,(char *)":new_MarkerMap")) SWIG_fail; - result = (aruco::MarkerMap *)new aruco::MarkerMap(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_create",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::FractalMarkerLabeler::create(arg1); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::FractalMarkerLabeler >(static_cast< const cv::Ptr< aruco::FractalMarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__FractalMarkerLabeler_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - std::string arg1 ; + FractalMarkerSet::CONF_TYPES arg1 ; + void *argp1 ; + int res1 = 0 ; PyObject * obj0 = 0 ; - aruco::MarkerMap *result = 0 ; + cv::Ptr< aruco::FractalMarkerLabeler > result; - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerMap",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_create",&obj0)) SWIG_fail; { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerMap" "', argument " "1"" of type '" "std::string""'"); + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FractalMarkerSet__CONF_TYPES, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_create" "', argument " "1"" of type '" "FractalMarkerSet::CONF_TYPES""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_create" "', argument " "1"" of type '" "FractalMarkerSet::CONF_TYPES""'"); + } else { + FractalMarkerSet::CONF_TYPES * temp = reinterpret_cast< FractalMarkerSet::CONF_TYPES * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; } - result = (aruco::MarkerMap *)new aruco::MarkerMap(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); + result = aruco::FractalMarkerLabeler::create(arg1); + resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::FractalMarkerLabeler >(static_cast< const cv::Ptr< aruco::FractalMarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__FractalMarkerLabeler_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MarkerMap(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_create(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 @@ -23815,266 +27112,326 @@ SWIGINTERN PyObject *_wrap_new_MarkerMap(PyObject *self, PyObject *args) { for (ii = 0; (ii < 1) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 0) { - return _wrap_new_MarkerMap__SWIG_0(self, args); + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FractalMarkerSet__CONF_TYPES, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FractalMarkerLabeler_create__SWIG_1(self, args); + } } if (argc == 1) { int _v; int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MarkerMap__SWIG_1(self, args); + return _wrap_FractalMarkerLabeler_create__SWIG_0(self, args); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerMap'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerLabeler_create'.\n" " Possible C/C++ prototypes are:\n" - " aruco::MarkerMap::MarkerMap()\n" - " aruco::MarkerMap::MarkerMap(std::string)\n"); + " aruco::FractalMarkerLabeler::create(std::string)\n" + " aruco::FractalMarkerLabeler::create(FractalMarkerSet::CONF_TYPES)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_setConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; + FractalMarkerSet *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - bool result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInMeters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerLabeler_setConfiguration",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_setConfiguration" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInMeters(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FractalMarkerSet, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerLabeler_setConfiguration" "', argument " "2"" of type '" "FractalMarkerSet const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_setConfiguration" "', argument " "2"" of type '" "FractalMarkerSet const &""'"); + } + arg2 = reinterpret_cast< FractalMarkerSet * >(argp2); + (arg1)->setConfiguration((FractalMarkerSet const &)*arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_FractalMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalMarkerLabeler",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalMarkerLabeler" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_getName" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler const *""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); + result = ((aruco::FractalMarkerLabeler const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; + cv::Mat *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + std::string *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInPixels",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalMarkerLabeler_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInPixels" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_detect" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); + { + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalMarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalMarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalMarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); + } + arg5 = reinterpret_cast< std::string * >(argp5); + result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + + } + { + if (arg2 != NULL) + delete arg2; } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInPixels(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: + { + if (arg2 != NULL) + delete arg2; + } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_convertToMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - float arg2 ; + aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::MarkerMap result; + int result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_convertToMeters",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_getNSubdivisions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_convertToMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_getNSubdivisions" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_convertToMeters" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = ((aruco::MarkerMap const *)arg1)->convertToMeters(arg2); - resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); + result = (int)((aruco::FractalMarkerLabeler const *)arg1)->getNSubdivisions(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_getIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler__fractalMarkerSet_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - vector< aruco::Marker > *arg2 = 0 ; + aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; + FractalMarkerSet arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - std::vector< int,std::allocator< int > > result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndices",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerLabeler__fractalMarkerSet_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndices" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_aruco__Marker_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler__fractalMarkerSet_set" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); + arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FractalMarkerSet, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerLabeler__fractalMarkerSet_set" "', argument " "2"" of type '" "FractalMarkerSet""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler__fractalMarkerSet_set" "', argument " "2"" of type '" "FractalMarkerSet""'"); + } else { + FractalMarkerSet * temp = reinterpret_cast< FractalMarkerSet * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } } - arg2 = reinterpret_cast< vector< aruco::Marker > * >(argp2); - result = ((aruco::MarkerMap const *)arg1)->getIndices((vector< aruco::Marker > const &)*arg2); - resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result)); + if (arg1) (arg1)->_fractalMarkerSet = arg2; + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_getMarker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerLabeler__fractalMarkerSet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - int arg2 ; + aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::Marker3DInfo *result = 0 ; + FractalMarkerSet result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getMarker3DInfo",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler__fractalMarkerSet_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler__fractalMarkerSet_get" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (aruco::Marker3DInfo *) &((aruco::MarkerMap const *)arg1)->getMarker3DInfo(arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); + arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); + result = ((arg1)->_fractalMarkerSet); + resultobj = SWIG_NewPointerObj((new FractalMarkerSet(static_cast< const FractalMarkerSet& >(result))), SWIGTYPE_p_FractalMarkerSet, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_getIndexOfMarkerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_FractalMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - int result; + aruco::FractalMarkerLabeler *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndexOfMarkerId",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (int)((aruco::MarkerMap const *)arg1)->getIndexOfMarkerId(arg2); - resultobj = SWIG_From_int(static_cast< int >(result)); + if (!PyArg_ParseTuple(args,(char *)":new_FractalMarkerLabeler")) SWIG_fail; + result = (aruco::FractalMarkerLabeler *)new aruco::FractalMarkerLabeler(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarkerLabeler, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FractalMarkerLabeler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalMarkerLabeler, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - vector< int > *arg2 = 0 ; - bool arg3 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + SwigValueWrapper< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > > arg2 ; + float arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; - bool val3 ; + float val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMap_getIdList",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_create",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_create" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_create" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_create" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >""'"); + } else { + std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * temp = reinterpret_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } } - arg2 = reinterpret_cast< vector< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); + ecode3 = SWIG_AsVal_float(obj2, &val3); if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_getIdList" "', argument " "3"" of type '" "bool""'"); + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_create" "', argument " "3"" of type '" "float""'"); } - arg3 = static_cast< bool >(val3); - ((aruco::MarkerMap const *)arg1)->getIdList(*arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - vector< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIdList",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); - } - arg2 = reinterpret_cast< vector< int > * >(argp2); - ((aruco::MarkerMap const *)arg1)->getIdList(*arg2); + arg3 = static_cast< float >(val3); + (arg1)->create(arg2,arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -24082,86 +27439,48 @@ SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MarkerMap_getIdList(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerMap_getIdList__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerMap_getIdList__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getIdList'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerMap::getIdList(vector< int > &,bool) const\n" - " aruco::MarkerMap::getIdList(vector< int > &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_configureMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - float arg2 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - float val2 ; + int val2 ; int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getImage",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalMarkerSet_configureMat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_configureMat" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getImage" "', argument " "2"" of type '" "float""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_configureMat" "', argument " "2"" of type '" "int""'"); } - arg2 = static_cast< float >(val2); - result = ((aruco::MarkerMap const *)arg1)->getImage(arg2); + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_configureMat" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalMarkerSet_configureMat" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + result = (arg1)->configureMat(arg2,arg3,arg4); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -24186,21 +27505,39 @@ SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_configureMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getImage",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_configureMat",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_configureMat" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = ((aruco::MarkerMap const *)arg1)->getImage(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_configureMat" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_configureMat" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (arg1)->configureMat(arg2,arg3); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -24225,312 +27562,225 @@ SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MarkerMap_getImage(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_configureMat(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[5] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { + for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 1) { + if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MarkerMap_getImage__SWIG_1(self, args); + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalMarkerSet_configureMat__SWIG_1(self, args); + } + } } } - if (argc == 2) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_float(argv[1], NULL); + int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_MarkerMap_getImage__SWIG_0(self, args); + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalMarkerSet_configureMat__SWIG_0(self, args); + } + } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getImage'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerSet_configureMat'.\n" " Possible C/C++ prototypes are:\n" - " aruco::MarkerMap::getImage(float) const\n" - " aruco::MarkerMap::getImage() const\n"); + " aruco::FractalMarkerSet::configureMat(int,int,int)\n" + " aruco::FractalMarkerSet::configureMat(int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MarkerMap_saveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_saveToFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_saveToFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_saveToFile" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->saveToFile(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_readFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_readFromFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_readFromFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_readFromFile" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->readFromFile(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_calculateExtrinsics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_dstMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; - float arg3 ; - cv::Mat arg4 ; - cv::Mat arg5 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + cv::Mat arg2 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - float val3 ; - int ecode3 = 0 ; - cv::Mat *mat4 ; - cv::Mat *mat5 ; + cv::Mat *mat2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - std::pair< cv::Mat,cv::Mat > result; + int result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerMap_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_dstMarker",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res2 = swig::asptr(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg2 = ptr; - } - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_dstMarker" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); { - mat5 = array_to_mat(obj4); - if (mat5 == NULL) + mat2 = array_to_mat(obj1); + if (mat2 == NULL) SWIG_fail; - arg5 = *mat5; - } - result = (arg1)->calculateExtrinsics((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2,arg3,arg4,arg5); - resultobj = SWIG_NewPointerObj((new std::pair< cv::Mat,cv::Mat >(static_cast< const std::pair< cv::Mat,cv::Mat >& >(result))), SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t, SWIG_POINTER_OWN | 0 ); - { - - } - { - - } - if (SWIG_IsNewObj(res2)) delete arg2; - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getDictionary",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getDictionary" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = ((aruco::MarkerMap const *)arg1)->getDictionary(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_setDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_setDictionary",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_setDictionary" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + arg2 = *mat2; } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + result = (int)(arg1)->dstMarker(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_setDictionary" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + + } + { + if (mat2 != NULL) + delete mat2; } - (arg1)->setDictionary(arg2); - resultobj = SWIG_Py_Void(); return resultobj; fail: + { + if (mat2 != NULL) + delete mat2; + } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_dstMarkerToMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - int arg2 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + cv::Mat arg2 ; + cv::Mat arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; + cv::Mat *mat2 ; + cv::Mat *mat3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + int result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_mInfoType_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_dstMarkerToMarker",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_set" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_dstMarkerToMarker" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + { + mat3 = array_to_mat(obj2); + if (mat3 == NULL) + SWIG_fail; + arg3 = *mat3; + } + result = (int)(arg1)->dstMarkerToMarker(arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + { + + } + { + + } + { + if (mat2 != NULL) + delete mat2; + } + { + if (mat3 != NULL) + delete mat3; } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_mInfoType_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->mInfoType = arg2; - resultobj = SWIG_Py_Void(); return resultobj; fail: + { + if (mat2 != NULL) + delete mat2; + } + { + if (mat3 != NULL) + delete mat3; + } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_dstMarkerToFractalDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + cv::Mat arg2 ; void *argp1 = 0 ; int res1 = 0 ; + cv::Mat *mat2 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_mInfoType_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_dstMarkerToFractalDict",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_get" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_dstMarkerToFractalDict" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = (int) ((arg1)->mInfoType); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + { + mat2 = array_to_mat(obj1); + if (mat2 == NULL) + SWIG_fail; + arg2 = *mat2; + } + result = (int)(arg1)->dstMarkerToFractalDict(arg2); resultobj = SWIG_From_int(static_cast< int >(result)); + { + + } + { + if (mat2 != NULL) + delete mat2; + } return resultobj; fail: + { + if (mat2 != NULL) + delete mat2; + } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMap_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet__toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + aruco::FractalMarkerSet *arg1 = 0 ; std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24539,21 +27789,24 @@ SWIGINTERN PyObject *_wrap_MarkerMap_toStream(PyObject *SWIGUNUSEDPARM(self), Py PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet__toStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__FractalMarkerSet, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_toStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet__toStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__toStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet__toStream" "', argument " "2"" of type '" "std::ostream &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__toStream" "', argument " "2"" of type '" "std::ostream &""'"); } arg2 = reinterpret_cast< std::ostream * >(argp2); - (arg1)->toStream(*arg2); + aruco::FractalMarkerSet::_toStream(*arg1,*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -24561,9 +27814,9 @@ SWIGINTERN PyObject *_wrap_MarkerMap_toStream(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_MarkerMap_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet__fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; + aruco::FractalMarkerSet *arg1 = 0 ; std::istream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24572,21 +27825,24 @@ SWIGINTERN PyObject *_wrap_MarkerMap_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet__fromStream",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__FractalMarkerSet, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_fromStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet__fromStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__fromStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet__fromStream" "', argument " "2"" of type '" "std::istream &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__fromStream" "', argument " "2"" of type '" "std::istream &""'"); } arg2 = reinterpret_cast< std::istream * >(argp2); - (arg1)->fromStream(*arg2); + aruco::FractalMarkerSet::_fromStream(*arg1,*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -24594,696 +27850,667 @@ SWIGINTERN PyObject *_wrap_MarkerMap_fromStream(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_delete_MarkerMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_isPredefinedConfigurationString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + std::string arg1 ; PyObject * obj0 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMap",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMap" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isPredefinedConfigurationString",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_isPredefinedConfigurationString" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); + result = (bool)aruco::FractalMarkerSet::isPredefinedConfigurationString(arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MarkerMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMap, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getTypeString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - aruco::Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - float arg4 ; - float arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; - float val5 ; - int ecode5 = 0 ; + aruco::FractalMarkerSet::CONF_TYPES arg1 ; + int val1 ; + int ecode1 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - bool result; + std::string result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - arg2 = reinterpret_cast< aruco::Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); - } - arg4 = static_cast< float >(val4); - ecode5 = SWIG_AsVal_float(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "5"" of type '" "float""'"); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getTypeString",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FractalMarkerSet_getTypeString" "', argument " "1"" of type '" "aruco::FractalMarkerSet::CONF_TYPES""'"); } - arg5 = static_cast< float >(val5); - result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg1 = static_cast< aruco::FractalMarkerSet::CONF_TYPES >(val1); + result = aruco::FractalMarkerSet::getTypeString(arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - aruco::Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - float arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; + std::string arg1 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - bool result; + aruco::FractalMarkerSet::CONF_TYPES result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getTypeFromString",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_getTypeFromString" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - arg2 = reinterpret_cast< aruco::Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + result = (aruco::FractalMarkerSet::CONF_TYPES)aruco::FractalMarkerSet::getTypeFromString(arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::FractalMarkerSet result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_load",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_load" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); + result = aruco::FractalMarkerSet::load(arg1); + resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_loadPredefined__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::FractalMarkerSet result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_loadPredefined",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_loadPredefined" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); + result = aruco::FractalMarkerSet::loadPredefined(arg1); + resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_loadPredefined__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalMarkerSet::CONF_TYPES arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + aruco::FractalMarkerSet result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_loadPredefined",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FractalMarkerSet_loadPredefined" "', argument " "1"" of type '" "aruco::FractalMarkerSet::CONF_TYPES""'"); } - arg4 = static_cast< float >(val4); - result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg1 = static_cast< aruco::FractalMarkerSet::CONF_TYPES >(val1); + result = aruco::FractalMarkerSet::loadPredefined(arg1); + resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_loadPredefined(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[6] = { + PyObject *argv[2] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { + for (ii = 0; (ii < 1) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 4) { + if (argc == 1) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); + { + int res = SWIG_AsVal_int(argv[0], NULL); _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerPoseTracker_estimatePose__SWIG_1(self, args); - } - } - } + } + if (_v) { + return _wrap_FractalMarkerSet_loadPredefined__SWIG_1(self, args); } } - if (argc == 5) { + if (argc == 1) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerPoseTracker_estimatePose__SWIG_0(self, args); - } - } - } - } + return _wrap_FractalMarkerSet_loadPredefined__SWIG_0(self, args); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerPoseTracker_estimatePose'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerSet_loadPredefined'.\n" " Possible C/C++ prototypes are:\n" - " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float,float)\n" - " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float)\n"); + " aruco::FractalMarkerSet::loadPredefined(std::string)\n" + " aruco::FractalMarkerSet::loadPredefined(aruco::FractalMarkerSet::CONF_TYPES)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_readFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + std::string arg1 ; + PyObject * obj0 = 0 ; + aruco::FractalMarkerSet result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_readFromFile",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_readFromFile" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::FractalMarkerSet::readFromFile(arg1); + resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_saveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + cv::FileStorage *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - cv::Mat result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRTMatrix",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_saveToFile",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_saveToFile" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - result = ((aruco::MarkerPoseTracker const *)arg1)->getRTMatrix(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__FileStorage, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_saveToFile" "', argument " "2"" of type '" "cv::FileStorage &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_saveToFile" "', argument " "2"" of type '" "cv::FileStorage &""'"); } + arg2 = reinterpret_cast< cv::FileStorage * >(argp2); + (arg1)->saveToFile(*arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_fractalMarkerCollection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + std::map< int,FractalMarker > arg2 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - cv::Mat result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_fractalMarkerCollection_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_fractalMarkerCollection_set" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - result = ((aruco::MarkerPoseTracker const *)arg1)->getRvec(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_FractalMarker_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_fractalMarkerCollection_set" "', argument " "2"" of type '" "std::map< int,FractalMarker >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_fractalMarkerCollection_set" "', argument " "2"" of type '" "std::map< int,FractalMarker >""'"); + } else { + std::map< int,FractalMarker > * temp = reinterpret_cast< std::map< int,FractalMarker > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->fractalMarkerCollection = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_fractalMarkerCollection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::map< int,FractalMarker > result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_fractalMarkerCollection_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_fractalMarkerCollection_get" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = ((arg1)->fractalMarkerCollection); + resultobj = SWIG_NewPointerObj((new std::map< int,FractalMarker >(static_cast< const std::map< int,FractalMarker >& >(result))), SWIGTYPE_p_std__mapT_int_FractalMarker_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_nbits_fractalMarkerIDs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + std::map< int,std::vector< int,std::allocator< int > > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - cv::Mat result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getTvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_nbits_fractalMarkerIDs_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_set" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - result = ((aruco::MarkerPoseTracker const *)arg1)->getTvec(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_set" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_set" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > >""'"); + } else { + std::map< int,std::vector< int,std::allocator< int > > > * temp = reinterpret_cast< std::map< int,std::vector< int,std::allocator< int > > > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->nbits_fractalMarkerIDs = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_nbits_fractalMarkerIDs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::map< int,std::vector< int,std::allocator< int > > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_nbits_fractalMarkerIDs_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_get" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = ((arg1)->nbits_fractalMarkerIDs); + resultobj = SWIG_NewPointerObj((new std::map< int,std::vector< int,std::allocator< int > > >(static_cast< const std::map< int,std::vector< int,std::allocator< int > > >& >(result))), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_isExpressedInMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerPoseTracker *result = 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)":new_MarkerPoseTracker")) SWIG_fail; - result = (aruco::MarkerPoseTracker *)new aruco::MarkerPoseTracker(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_NEW | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isExpressedInMeters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isExpressedInMeters" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (bool)((aruco::FractalMarkerSet const *)arg1)->isExpressedInMeters(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_isExpressedInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerPoseTracker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isExpressedInPixels",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerPoseTracker" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isExpressedInPixels" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (bool)((aruco::FractalMarkerSet const *)arg1)->isExpressedInPixels(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MarkerPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_isNormalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *result = 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)":new_MarkerMapPoseTracker")) SWIG_fail; - result = (aruco::MarkerMapPoseTracker *)new aruco::MarkerMapPoseTracker(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_NEW | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isNormalize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isNormalize" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (bool)((aruco::FractalMarkerSet const *)arg1)->isNormalize(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - aruco::CameraParameters *arg2 = 0 ; - aruco::MarkerMap *arg3 = 0 ; - float arg4 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; + aruco::FractalMarkerSet result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_normalize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_normalize" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); - } - arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "4"" of type '" "float""'"); - } - arg4 = static_cast< float >(val4); - (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3,arg4); - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (arg1)->normalize(); + resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_convertToMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - aruco::CameraParameters *arg2 = 0 ; - aruco::MarkerMap *arg3 = 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + float arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + float val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + aruco::FractalMarkerSet result; - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_convertToMeters",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_convertToMeters" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); - (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3); - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_convertToMeters" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + result = (arg1)->convertToMeters(arg2); + resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerMapPoseTracker_setParams__SWIG_1(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerMapPoseTracker_setParams__SWIG_0(self, args); - } - } - } - } - } +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getConfigurations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< std::vector< std::string,std::allocator< std::string > > > result; + if (!PyArg_ParseTuple(args,(char *)":FractalMarkerSet_getConfigurations")) SWIG_fail; + result = aruco::FractalMarkerSet::getConfigurations(); + resultobj = SWIG_NewPointerObj((new std::vector< std::string,std::allocator< std::string > >(static_cast< const std::vector< std::string,std::allocator< std::string > >& >(result))), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMapPoseTracker_setParams'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &,float)\n" - " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - bool result; + float result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_isValid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getFractalSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_isValid" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getFractalSize" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = (bool)((aruco::MarkerMapPoseTracker const *)arg1)->isValid(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (float)((aruco::FractalMarkerSet const *)arg1)->getFractalSize(); + resultobj = SWIG_From_float(static_cast< float >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_nBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; + int result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_reset",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_nBits",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_reset" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_nBits" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - (arg1)->reset(); - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (int)((aruco::FractalMarkerSet const *)arg1)->nBits(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_estimatePose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_isFractalMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + cv::Mat *arg2 = 0 ; + int arg3 ; + int *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; + uchar *data_ptr2 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMapPoseTracker_estimatePose",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalMarkerSet_isFractalMarker",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res2 = swig::asptr(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); + arg2 = array_to_mat(obj1); + if (arg2 == NULL) + SWIG_fail; + // save dataptr to check whether it changed + data_ptr2 = arg2->data; + } + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + result = (bool)(arg1)->isFractalMarker(*arg2,arg3,*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + { + // check if the underlying data changed + if (data_ptr2 != arg2->data) { + // TODO don't fail if we can reallocate the underlying memory + // (not always possible due to the way NumPy does reference counting) + PyErr_Format(PyExc_RuntimeError, + "Underlying data changed. Please make sure that the " + "input data is of correct size and type: %d %d %d", + arg2->rows, arg2->cols, arg2->type()); + SWIG_fail; } - arg2 = ptr; } - result = (bool)(arg1)->estimatePose((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - if (SWIG_IsNewObj(res2)) delete arg2; + { + if (arg2 != NULL) + delete arg2; + } return resultobj; fail: - if (SWIG_IsNewObj(res2)) delete arg2; + { + if (arg2 != NULL) + delete arg2; + } return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getInnerCorners(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - cv::Mat result; + std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > > result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRTMatrix",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getInnerCorners",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRTMatrix(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getInnerCorners" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (arg1)->getInnerCorners(); + resultobj = SWIG_NewPointerObj((new std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > >(static_cast< const std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > >& >(result))), SWIGTYPE_p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + int arg2 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_getFractalMarkerImage",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRvec(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + result = (arg1)->getFractalMarkerImage(arg2,arg3); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -25308,21 +28535,30 @@ SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getTvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_getFractalMarkerImage",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = ((aruco::MarkerMapPoseTracker const *)arg1)->getTvec(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (arg1)->getFractalMarkerImage(arg2); { PyObject* array = mat_to_array(result); if (array == NULL) @@ -25347,38 +28583,87 @@ SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setMaxTrackingDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalMarkerImage(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerSet_getFractalMarkerImage'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::FractalMarkerSet::getFractalMarkerImage(int,bool)\n" + " aruco::FractalMarkerSet::getFractalMarkerImage(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_FractalMarkerSet_mInfoType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - float arg2 ; - float arg3 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - float val2 ; + int val2 ; int ecode2 = 0 ; - float val3 ; - int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setMaxTrackingDifference",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_mInfoType_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_mInfoType_set" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "3"" of type '" "float""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_mInfoType_set" "', argument " "2"" of type '" "int""'"); } - arg3 = static_cast< float >(val3); - (arg1)->setMaxTrackingDifference(arg2,arg3); + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->mInfoType = arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -25386,47 +28671,54 @@ SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setMaxTrackingDifference(PyObjec } -SWIGINTERN PyObject *_wrap_delete_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarkerSet_mInfoType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; + int result; - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMapPoseTracker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_mInfoType_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMapPoseTracker" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_mInfoType_get" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); + result = (int) ((arg1)->mInfoType); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MarkerMapPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_new_FractalMarkerSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + aruco::FractalMarkerSet *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_FractalMarkerSet")) SWIG_fail; + result = (aruco::FractalMarkerSet *)new aruco::FractalMarkerSet(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap_delete_DictionaryBased(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + +SWIGINTERN PyObject *_wrap_delete_FractalMarkerSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; + aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_DictionaryBased",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalMarkerSet",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DictionaryBased" "', argument " "1"" of type '" "aruco::DictionaryBased *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalMarkerSet" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); } - arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); + arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; @@ -25435,445 +28727,351 @@ SWIGINTERN PyObject *_wrap_delete_DictionaryBased(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_DictionaryBased_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FractalMarkerSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_FractalMarker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; - aruco::Dictionary *arg2 = 0 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + aruco::FractalMarker *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:DictionaryBased_setParams",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_setParams" "', argument " "1"" of type '" "aruco::DictionaryBased *""'"); - } - arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Dictionary, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DictionaryBased_setParams" "', argument " "2"" of type '" "aruco::Dictionary const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_setParams" "', argument " "2"" of type '" "aruco::Dictionary const &""'"); - } - arg2 = reinterpret_cast< aruco::Dictionary * >(argp2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DictionaryBased_setParams" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setParams((aruco::Dictionary const &)*arg2,arg3); - resultobj = SWIG_Py_Void(); + if (!PyArg_ParseTuple(args,(char *)":new_FractalMarker")) SWIG_fail; + result = (aruco::FractalMarker *)new aruco::FractalMarker(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarker, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DictionaryBased_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_FractalMarker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; - cv::Mat *arg2 = 0 ; - int *arg3 = 0 ; - int *arg4 = 0 ; - std::string *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; + int arg1 ; + cv::Mat arg2 ; + SwigValueWrapper< std::vector< cv::Point3f,std::allocator< cv::Point3f > > > arg3 ; + std::vector< int,std::allocator< int > > arg4 ; + int val1 ; + int ecode1 = 0 ; + cv::Mat *mat2 ; + void *argp3 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - bool result; + aruco::FractalMarker *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:DictionaryBased_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_detect" "', argument " "1"" of type '" "aruco::DictionaryBased *""'"); - } - arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); + if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FractalMarker",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FractalMarker" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) + mat2 = array_to_mat(obj1); + if (mat2 == NULL) SWIG_fail; + arg2 = *mat2; } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DictionaryBased_detect" "', argument " "3"" of type '" "int &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_detect" "', argument " "3"" of type '" "int &""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DictionaryBased_detect" "', argument " "4"" of type '" "int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_detect" "', argument " "4"" of type '" "int &""'"); - } - arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DictionaryBased_detect" "', argument " "5"" of type '" "std::string &""'"); + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FractalMarker" "', argument " "3"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > >""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FractalMarker" "', argument " "3"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > >""'"); + } else { + std::vector< cv::Point3f,std::allocator< cv::Point3f > > * temp = reinterpret_cast< std::vector< cv::Point3f,std::allocator< cv::Point3f > > * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DictionaryBased_detect" "', argument " "5"" of type '" "std::string &""'"); + { + std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; + int res = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FractalMarker" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); + } + arg4 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - arg5 = reinterpret_cast< std::string * >(argp5); - result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + result = (aruco::FractalMarker *)new aruco::FractalMarker(arg1,arg2,arg3,arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarker, SWIG_POINTER_NEW | 0 ); { } { - if (arg2 != NULL) - delete arg2; + if (mat2 != NULL) + delete mat2; } return resultobj; fail: { - if (arg2 != NULL) - delete arg2; + if (mat2 != NULL) + delete mat2; } return NULL; } -SWIGINTERN PyObject *_wrap_DictionaryBased_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; +SWIGINTERN PyObject *_wrap_new_FractalMarker(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"O:DictionaryBased_getName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_getName" "', argument " "1"" of type '" "aruco::DictionaryBased const *""'"); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 4) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); - result = ((aruco::DictionaryBased const *)arg1)->getName(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; + if (argc == 0) { + return _wrap_new_FractalMarker__SWIG_0(self, args); + } + if (argc == 4) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + _v = is_array(argv[1]) || PySequence_Check(argv[1]); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_FractalMarker__SWIG_1(self, args); + } + } + } + } + } + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FractalMarker'.\n" + " Possible C/C++ prototypes are:\n" + " aruco::FractalMarker::FractalMarker()\n" + " aruco::FractalMarker::FractalMarker(int,cv::Mat,std::vector< cv::Point3f,std::allocator< cv::Point3f > >,std::vector< int,std::allocator< int > >)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_DictionaryBased_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarker_addSubFractalMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::DictionaryBased *arg1 = (aruco::DictionaryBased *) 0 ; + aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; + aruco::FractalMarker arg2 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - int result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:DictionaryBased_getNSubdivisions",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__DictionaryBased, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarker_addSubFractalMarker",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DictionaryBased_getNSubdivisions" "', argument " "1"" of type '" "aruco::DictionaryBased const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_addSubFractalMarker" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); } - arg1 = reinterpret_cast< aruco::DictionaryBased * >(argp1); - result = (int)((aruco::DictionaryBased const *)arg1)->getNSubdivisions(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DictionaryBased(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::DictionaryBased *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_DictionaryBased")) SWIG_fail; - result = (aruco::DictionaryBased *)new aruco::DictionaryBased(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__DictionaryBased, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *DictionaryBased_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__DictionaryBased, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_SVMMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::SVMMarkers *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_SVMMarkers")) SWIG_fail; - result = (aruco::SVMMarkers *)new aruco::SVMMarkers(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__SVMMarkers, SWIG_POINTER_NEW | 0 ); + arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__FractalMarker, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarker_addSubFractalMarker" "', argument " "2"" of type '" "aruco::FractalMarker""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarker_addSubFractalMarker" "', argument " "2"" of type '" "aruco::FractalMarker""'"); + } else { + aruco::FractalMarker * temp = reinterpret_cast< aruco::FractalMarker * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->addSubFractalMarker(arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SVMMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarker_getInnerCorners(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; + SwigValueWrapper< std::vector< cv::Point3f,std::allocator< cv::Point3f > > > result; - if (!PyArg_ParseTuple(args,(char *)"O:delete_SVMMarkers",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_getInnerCorners",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SVMMarkers" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_getInnerCorners" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); } - arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); + result = (arg1)->getInnerCorners(); + resultobj = SWIG_NewPointerObj((new std::vector< cv::Point3f,std::allocator< cv::Point3f > >(static_cast< const std::vector< cv::Point3f,std::allocator< cv::Point3f > >& >(result))), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SVMMarkers_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarker_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - std::string result; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"O:SVMMarkers_getName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_mat",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_getName" "', argument " "1"" of type '" "aruco::SVMMarkers const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_mat" "', argument " "1"" of type '" "aruco::FractalMarker const *""'"); + } + arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); + result = ((aruco::FractalMarker const *)arg1)->mat(); + { + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); - result = ((aruco::SVMMarkers const *)arg1)->getName(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SVMMarkers_load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarker_mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; - std::string arg2 ; + aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; + cv::Mat result; - if (!PyArg_ParseTuple(args,(char *)"OO:SVMMarkers_load",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_mask",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_load" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_mask" "', argument " "1"" of type '" "aruco::FractalMarker const *""'"); } - arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); + arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); + result = ((aruco::FractalMarker const *)arg1)->mask(); { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SVMMarkers_load" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + PyObject* array = mat_to_array(result); + if (array == NULL) + SWIG_fail; + + // add a reference to the underlying cv::Mat so + // that the memory is not freed before the NumPy array + // is released or reassigned + cv::Mat *m = new cv::Mat(result); + // printf("created new mat object at %p\n", m); +#ifdef CAPSULES_SUPPORTED + PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); +#else + PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); +#endif + + resultobj = array; } - result = (bool)(arg1)->load(arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SVMMarkers_load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarker_nBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - bool result; + int result; - if (!PyArg_ParseTuple(args,(char *)"O:SVMMarkers_load",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_nBits",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_load" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_nBits" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); } - arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); - result = (bool)(arg1)->load(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); + result = (int)(arg1)->nBits(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SVMMarkers_load(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__SVMMarkers, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SVMMarkers_load__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__SVMMarkers, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SVMMarkers_load__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SVMMarkers_load'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::SVMMarkers::load(std::string)\n" - " aruco::SVMMarkers::load()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SVMMarkers_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FractalMarker_subMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; - cv::Mat *arg2 = 0 ; - int *arg3 = 0 ; - int *arg4 = 0 ; - std::string *arg5 = 0 ; + aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - bool result; + std::vector< int,std::allocator< int > > result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:SVMMarkers_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_subMarkers",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_detect" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); - } - arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SVMMarkers_detect" "', argument " "3"" of type '" "int &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVMMarkers_detect" "', argument " "3"" of type '" "int &""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SVMMarkers_detect" "', argument " "4"" of type '" "int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVMMarkers_detect" "', argument " "4"" of type '" "int &""'"); - } - arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SVMMarkers_detect" "', argument " "5"" of type '" "std::string &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVMMarkers_detect" "', argument " "5"" of type '" "std::string &""'"); - } - arg5 = reinterpret_cast< std::string * >(argp5); - result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - { - - } - { - if (arg2 != NULL) - delete arg2; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_subMarkers" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); } + arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); + result = (arg1)->subMarkers(); + resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result)); return resultobj; fail: - { - if (arg2 != NULL) - delete arg2; - } return NULL; } -SWIGINTERN PyObject *_wrap_SVMMarkers_getBestInputSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_FractalMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - aruco::SVMMarkers *arg1 = (aruco::SVMMarkers *) 0 ; + aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - int result; - if (!PyArg_ParseTuple(args,(char *)"O:SVMMarkers_getBestInputSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__SVMMarkers, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalMarker",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVMMarkers_getBestInputSize" "', argument " "1"" of type '" "aruco::SVMMarkers *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalMarker" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); } - arg1 = reinterpret_cast< aruco::SVMMarkers * >(argp1); - result = (int)(arg1)->getBestInputSize(); - resultobj = SWIG_From_int(static_cast< int >(result)); + arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *SVMMarkers_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FractalMarker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__SVMMarkers, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalMarker, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -27432,6 +30630,30 @@ SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Py_Void(); } +SWIGINTERN PyObject *_wrap___pf_aruco_methodName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::string arg1 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:__pf_aruco_methodName",&obj0)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(obj0, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "__pf_aruco_methodName" "', argument " "1"" of type '" "std::string""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = aruco::__pf_aruco_methodName(arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + static PyMethodDef SwigMethods[] = { { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL}, @@ -27665,11 +30887,13 @@ static PyMethodDef SwigMethods[] = { { (char *)"Marker_getCenter", _wrap_Marker_getCenter, METH_VARARGS, NULL}, { (char *)"Marker_getPerimeter", _wrap_Marker_getPerimeter, METH_VARARGS, NULL}, { (char *)"Marker_getArea", _wrap_Marker_getArea, METH_VARARGS, NULL}, + { (char *)"Marker_getRadius", _wrap_Marker_getRadius, METH_VARARGS, NULL}, { (char *)"Marker___eq__", _wrap_Marker___eq__, METH_VARARGS, NULL}, { (char *)"Marker_copyTo", _wrap_Marker_copyTo, METH_VARARGS, NULL}, { (char *)"Marker_toStream", _wrap_Marker_toStream, METH_VARARGS, NULL}, { (char *)"Marker_fromStream", _wrap_Marker_fromStream, METH_VARARGS, NULL}, { (char *)"Marker_get3DPoints", _wrap_Marker_get3DPoints, METH_VARARGS, NULL}, + { (char *)"Marker_getTransformMatrix", _wrap_Marker_getTransformMatrix, METH_VARARGS, NULL}, { (char *)"Marker___getitem__", _wrap_Marker___getitem__, METH_VARARGS, NULL}, { (char *)"Marker_swigregister", Marker_swigregister, METH_VARARGS, NULL}, { (char *)"new_MarkerDetector", _wrap_new_MarkerDetector, METH_VARARGS, NULL}, @@ -27682,11 +30906,11 @@ static PyMethodDef SwigMethods[] = { { (char *)"MarkerDetector_getParameters", _wrap_MarkerDetector_getParameters, METH_VARARGS, NULL}, { (char *)"MarkerDetector_setDictionary", _wrap_MarkerDetector_setDictionary, METH_VARARGS, NULL}, { (char *)"MarkerDetector_getThresholdedImage", _wrap_MarkerDetector_getThresholdedImage, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_getNhresholdedImages", _wrap_MarkerDetector_getNhresholdedImages, METH_VARARGS, NULL}, { (char *)"MarkerDetector_setMarkerLabeler", _wrap_MarkerDetector_setMarkerLabeler, METH_VARARGS, NULL}, { (char *)"MarkerDetector_getMarkerLabeler", _wrap_MarkerDetector_getMarkerLabeler, METH_VARARGS, NULL}, { (char *)"MarkerDetector_getCandidates", _wrap_MarkerDetector_getCandidates, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_warp", _wrap_MarkerDetector_warp, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_getImagePyramid", _wrap_MarkerDetector_getImagePyramid, METH_VARARGS, NULL}, + { (char *)"MarkerDetector_cornerUpsample", _wrap_MarkerDetector_cornerUpsample, METH_VARARGS, NULL}, { (char *)"MarkerDetector_toStream", _wrap_MarkerDetector_toStream, METH_VARARGS, NULL}, { (char *)"MarkerDetector_fromStream", _wrap_MarkerDetector_fromStream, METH_VARARGS, NULL}, { (char *)"MarkerDetector_setParameters", _wrap_MarkerDetector_setParameters, METH_VARARGS, NULL}, @@ -27698,6 +30922,21 @@ static PyMethodDef SwigMethods[] = { { (char *)"MarkerLabeler_getName", _wrap_MarkerLabeler_getName, METH_VARARGS, NULL}, { (char *)"delete_MarkerLabeler", _wrap_delete_MarkerLabeler, METH_VARARGS, NULL}, { (char *)"MarkerLabeler_swigregister", MarkerLabeler_swigregister, METH_VARARGS, NULL}, + { (char *)"new_FractalDetector", _wrap_new_FractalDetector, METH_VARARGS, NULL}, + { (char *)"FractalDetector_setConfiguration", _wrap_FractalDetector_setConfiguration, METH_VARARGS, NULL}, + { (char *)"FractalDetector_setParams", _wrap_FractalDetector_setParams, METH_VARARGS, NULL}, + { (char *)"FractalDetector_getConfiguration", _wrap_FractalDetector_getConfiguration, METH_VARARGS, NULL}, + { (char *)"FractalDetector_detect", _wrap_FractalDetector_detect, METH_VARARGS, NULL}, + { (char *)"FractalDetector_poseEstimation", _wrap_FractalDetector_poseEstimation, METH_VARARGS, NULL}, + { (char *)"FractalDetector_getRvec", _wrap_FractalDetector_getRvec, METH_VARARGS, NULL}, + { (char *)"FractalDetector_getTvec", _wrap_FractalDetector_getTvec, METH_VARARGS, NULL}, + { (char *)"FractalDetector_drawMarkers", _wrap_FractalDetector_drawMarkers, METH_VARARGS, NULL}, + { (char *)"FractalDetector_draw2d", _wrap_FractalDetector_draw2d, METH_VARARGS, NULL}, + { (char *)"FractalDetector_draw3d", _wrap_FractalDetector_draw3d, METH_VARARGS, NULL}, + { (char *)"FractalDetector_draw3dCube", _wrap_FractalDetector_draw3dCube, METH_VARARGS, NULL}, + { (char *)"FractalDetector_getMarkers", _wrap_FractalDetector_getMarkers, METH_VARARGS, NULL}, + { (char *)"delete_FractalDetector", _wrap_delete_FractalDetector, METH_VARARGS, NULL}, + { (char *)"FractalDetector_swigregister", FractalDetector_swigregister, METH_VARARGS, NULL}, { (char *)"Marker3DInfo_points_set", _wrap_Marker3DInfo_points_set, METH_VARARGS, NULL}, { (char *)"Marker3DInfo_points_get", _wrap_Marker3DInfo_points_get, METH_VARARGS, NULL}, { (char *)"Marker3DInfo_id_set", _wrap_Marker3DInfo_id_set, METH_VARARGS, NULL}, @@ -27750,20 +30989,76 @@ static PyMethodDef SwigMethods[] = { { (char *)"MarkerMapPoseTracker_setMaxTrackingDifference", _wrap_MarkerMapPoseTracker_setMaxTrackingDifference, METH_VARARGS, NULL}, { (char *)"delete_MarkerMapPoseTracker", _wrap_delete_MarkerMapPoseTracker, METH_VARARGS, NULL}, { (char *)"MarkerMapPoseTracker_swigregister", MarkerMapPoseTracker_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_DictionaryBased", _wrap_delete_DictionaryBased, METH_VARARGS, NULL}, - { (char *)"DictionaryBased_setParams", _wrap_DictionaryBased_setParams, METH_VARARGS, NULL}, - { (char *)"DictionaryBased_detect", _wrap_DictionaryBased_detect, METH_VARARGS, NULL}, - { (char *)"DictionaryBased_getName", _wrap_DictionaryBased_getName, METH_VARARGS, NULL}, - { (char *)"DictionaryBased_getNSubdivisions", _wrap_DictionaryBased_getNSubdivisions, METH_VARARGS, NULL}, - { (char *)"new_DictionaryBased", _wrap_new_DictionaryBased, METH_VARARGS, NULL}, - { (char *)"DictionaryBased_swigregister", DictionaryBased_swigregister, METH_VARARGS, NULL}, - { (char *)"new_SVMMarkers", _wrap_new_SVMMarkers, METH_VARARGS, NULL}, - { (char *)"delete_SVMMarkers", _wrap_delete_SVMMarkers, METH_VARARGS, NULL}, - { (char *)"SVMMarkers_getName", _wrap_SVMMarkers_getName, METH_VARARGS, NULL}, - { (char *)"SVMMarkers_load", _wrap_SVMMarkers_load, METH_VARARGS, NULL}, - { (char *)"SVMMarkers_detect", _wrap_SVMMarkers_detect, METH_VARARGS, NULL}, - { (char *)"SVMMarkers_getBestInputSize", _wrap_SVMMarkers_getBestInputSize, METH_VARARGS, NULL}, - { (char *)"SVMMarkers_swigregister", SVMMarkers_swigregister, METH_VARARGS, NULL}, + { (char *)"PicoFlann_KeyPointAdapter___call__", _wrap_PicoFlann_KeyPointAdapter___call__, METH_VARARGS, NULL}, + { (char *)"new_PicoFlann_KeyPointAdapter", _wrap_new_PicoFlann_KeyPointAdapter, METH_VARARGS, NULL}, + { (char *)"delete_PicoFlann_KeyPointAdapter", _wrap_delete_PicoFlann_KeyPointAdapter, METH_VARARGS, NULL}, + { (char *)"PicoFlann_KeyPointAdapter_swigregister", PicoFlann_KeyPointAdapter_swigregister, METH_VARARGS, NULL}, + { (char *)"new_FractalPoseTracker", _wrap_new_FractalPoseTracker, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_setParams", _wrap_FractalPoseTracker_setParams, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_fractalInnerPose", _wrap_FractalPoseTracker_fractalInnerPose, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_ROI", _wrap_FractalPoseTracker_ROI, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_assignClass", _wrap_FractalPoseTracker_assignClass, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_fractal_solve_ransac", _wrap_FractalPoseTracker_fractal_solve_ransac, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_fractalRefinement", _wrap_FractalPoseTracker_fractalRefinement, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_getRvec", _wrap_FractalPoseTracker_getRvec, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_getTvec", _wrap_FractalPoseTracker_getTvec, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_getInner3d", _wrap_FractalPoseTracker_getInner3d, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_isPoseValid", _wrap_FractalPoseTracker_isPoseValid, METH_VARARGS, NULL}, + { (char *)"delete_FractalPoseTracker", _wrap_delete_FractalPoseTracker, METH_VARARGS, NULL}, + { (char *)"FractalPoseTracker_swigregister", FractalPoseTracker_swigregister, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler_create", _wrap_FractalMarkerLabeler_create, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler_setConfiguration", _wrap_FractalMarkerLabeler_setConfiguration, METH_VARARGS, NULL}, + { (char *)"delete_FractalMarkerLabeler", _wrap_delete_FractalMarkerLabeler, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler_getName", _wrap_FractalMarkerLabeler_getName, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler_detect", _wrap_FractalMarkerLabeler_detect, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler_getNSubdivisions", _wrap_FractalMarkerLabeler_getNSubdivisions, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler__fractalMarkerSet_set", _wrap_FractalMarkerLabeler__fractalMarkerSet_set, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler__fractalMarkerSet_get", _wrap_FractalMarkerLabeler__fractalMarkerSet_get, METH_VARARGS, NULL}, + { (char *)"new_FractalMarkerLabeler", _wrap_new_FractalMarkerLabeler, METH_VARARGS, NULL}, + { (char *)"FractalMarkerLabeler_swigregister", FractalMarkerLabeler_swigregister, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_create", _wrap_FractalMarkerSet_create, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_configureMat", _wrap_FractalMarkerSet_configureMat, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_dstMarker", _wrap_FractalMarkerSet_dstMarker, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_dstMarkerToMarker", _wrap_FractalMarkerSet_dstMarkerToMarker, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_dstMarkerToFractalDict", _wrap_FractalMarkerSet_dstMarkerToFractalDict, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet__toStream", _wrap_FractalMarkerSet__toStream, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet__fromStream", _wrap_FractalMarkerSet__fromStream, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_isPredefinedConfigurationString", _wrap_FractalMarkerSet_isPredefinedConfigurationString, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_getTypeString", _wrap_FractalMarkerSet_getTypeString, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_getTypeFromString", _wrap_FractalMarkerSet_getTypeFromString, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_load", _wrap_FractalMarkerSet_load, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_loadPredefined", _wrap_FractalMarkerSet_loadPredefined, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_readFromFile", _wrap_FractalMarkerSet_readFromFile, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_saveToFile", _wrap_FractalMarkerSet_saveToFile, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_fractalMarkerCollection_set", _wrap_FractalMarkerSet_fractalMarkerCollection_set, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_fractalMarkerCollection_get", _wrap_FractalMarkerSet_fractalMarkerCollection_get, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_nbits_fractalMarkerIDs_set", _wrap_FractalMarkerSet_nbits_fractalMarkerIDs_set, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_nbits_fractalMarkerIDs_get", _wrap_FractalMarkerSet_nbits_fractalMarkerIDs_get, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_isExpressedInMeters", _wrap_FractalMarkerSet_isExpressedInMeters, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_isExpressedInPixels", _wrap_FractalMarkerSet_isExpressedInPixels, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_isNormalize", _wrap_FractalMarkerSet_isNormalize, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_normalize", _wrap_FractalMarkerSet_normalize, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_convertToMeters", _wrap_FractalMarkerSet_convertToMeters, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_getConfigurations", _wrap_FractalMarkerSet_getConfigurations, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_getFractalSize", _wrap_FractalMarkerSet_getFractalSize, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_nBits", _wrap_FractalMarkerSet_nBits, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_isFractalMarker", _wrap_FractalMarkerSet_isFractalMarker, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_getInnerCorners", _wrap_FractalMarkerSet_getInnerCorners, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_getFractalMarkerImage", _wrap_FractalMarkerSet_getFractalMarkerImage, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_mInfoType_set", _wrap_FractalMarkerSet_mInfoType_set, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_mInfoType_get", _wrap_FractalMarkerSet_mInfoType_get, METH_VARARGS, NULL}, + { (char *)"new_FractalMarkerSet", _wrap_new_FractalMarkerSet, METH_VARARGS, NULL}, + { (char *)"delete_FractalMarkerSet", _wrap_delete_FractalMarkerSet, METH_VARARGS, NULL}, + { (char *)"FractalMarkerSet_swigregister", FractalMarkerSet_swigregister, METH_VARARGS, NULL}, + { (char *)"new_FractalMarker", _wrap_new_FractalMarker, METH_VARARGS, NULL}, + { (char *)"FractalMarker_addSubFractalMarker", _wrap_FractalMarker_addSubFractalMarker, METH_VARARGS, NULL}, + { (char *)"FractalMarker_getInnerCorners", _wrap_FractalMarker_getInnerCorners, METH_VARARGS, NULL}, + { (char *)"FractalMarker_mat", _wrap_FractalMarker_mat, METH_VARARGS, NULL}, + { (char *)"FractalMarker_mask", _wrap_FractalMarker_mask, METH_VARARGS, NULL}, + { (char *)"FractalMarker_nBits", _wrap_FractalMarker_nBits, METH_VARARGS, NULL}, + { (char *)"FractalMarker_subMarkers", _wrap_FractalMarker_subMarkers, METH_VARARGS, NULL}, + { (char *)"delete_FractalMarker", _wrap_delete_FractalMarker, METH_VARARGS, NULL}, + { (char *)"FractalMarker_swigregister", FractalMarker_swigregister, METH_VARARGS, NULL}, { (char *)"ScopeTimer_begin_set", _wrap_ScopeTimer_begin_set, METH_VARARGS, NULL}, { (char *)"ScopeTimer_begin_get", _wrap_ScopeTimer_begin_get, METH_VARARGS, NULL}, { (char *)"ScopeTimer_end_set", _wrap_ScopeTimer_end_set, METH_VARARGS, NULL}, @@ -27806,32 +31101,40 @@ static PyMethodDef SwigMethods[] = { { (char *)"Timer_getAverage", _wrap_Timer_getAverage, METH_VARARGS, NULL}, { (char *)"delete_Timer", _wrap_delete_Timer, METH_VARARGS, NULL}, { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL}, + { (char *)"__pf_aruco_methodName", _wrap___pf_aruco_methodName, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ +static void *_p_aruco__FractalMarkerTo_p_aruco__Marker3DInfo(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((aruco::Marker3DInfo *) ((aruco::FractalMarker *) x)); +} static void *_p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((std::vector< cv::Point2f,std::allocator< cv::Point2f > > *) ((aruco::Marker *) x)); } static void *_p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *) ((aruco::MarkerMap *) x)); } -static void *_p_aruco__SVMMarkersTo_p_aruco__MarkerLabeler(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((aruco::MarkerLabeler *) ((aruco::SVMMarkers *) x)); -} -static void *_p_aruco__DictionaryBasedTo_p_aruco__MarkerLabeler(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((aruco::MarkerLabeler *) ((aruco::DictionaryBased *) x)); +static void *_p_aruco__FractalMarkerLabelerTo_p_aruco__MarkerLabeler(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((aruco::MarkerLabeler *) ((aruco::FractalMarkerLabeler *) x)); } +static swig_type_info _swigt__p_FractalMarker = {"_p_FractalMarker", "FractalMarker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_FractalMarkerSet = {"_p_FractalMarkerSet", "FractalMarkerSet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_FractalMarkerSet__CONF_TYPES = {"_p_FractalMarkerSet__CONF_TYPES", "FractalMarkerSet::CONF_TYPES *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Marker = {"_p_Marker", "Marker *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__CameraParameters = {"_p_aruco__CameraParameters", "aruco::CameraParameters *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__CvDrawingUtils = {"_p_aruco__CvDrawingUtils", "aruco::CvDrawingUtils *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__Debug = {"_p_aruco__Debug", "aruco::Debug *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__Dictionary = {"_p_aruco__Dictionary", "aruco::Dictionary *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__DictionaryBased = {"_p_aruco__DictionaryBased", "aruco::DictionaryBased *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__Marker = {"_p_aruco__Marker", "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *|aruco::Marker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__FractalDetector = {"_p_aruco__FractalDetector", "aruco::FractalDetector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__FractalMarker = {"_p_aruco__FractalMarker", "aruco::FractalMarker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__FractalMarkerLabeler = {"_p_aruco__FractalMarkerLabeler", "aruco::FractalMarkerLabeler *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__FractalMarkerSet = {"_p_aruco__FractalMarkerSet", "aruco::FractalMarkerSet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__FractalPoseTracker = {"_p_aruco__FractalPoseTracker", "aruco::FractalPoseTracker *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__Marker = {"_p_aruco__Marker", "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *|aruco::MarkerCandidate *|aruco::Marker *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__Marker3DInfo = {"_p_aruco__Marker3DInfo", "aruco::Marker3DInfo *|std::vector< aruco::Marker3DInfo >::value_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerDetector = {"_p_aruco__MarkerDetector", "aruco::MarkerDetector *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerDetector__Params = {"_p_aruco__MarkerDetector__Params", "aruco::MarkerDetector::Params *", 0, 0, (void*)0, 0}; @@ -27839,17 +31142,22 @@ static swig_type_info _swigt__p_aruco__MarkerLabeler = {"_p_aruco__MarkerLabeler static swig_type_info _swigt__p_aruco__MarkerMap = {"_p_aruco__MarkerMap", "aruco::MarkerMap *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerMapPoseTracker = {"_p_aruco__MarkerMapPoseTracker", "aruco::MarkerMapPoseTracker *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__MarkerPoseTracker = {"_p_aruco__MarkerPoseTracker", "aruco::MarkerPoseTracker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__SVMMarkers = {"_p_aruco__SVMMarkers", "aruco::SVMMarkers *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_aruco__PicoFlann_KeyPointAdapter = {"_p_aruco__PicoFlann_KeyPointAdapter", "aruco::PicoFlann_KeyPointAdapter *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__ScopeTimer = {"_p_aruco__ScopeTimer", "aruco::ScopeTimer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__ScopedTimerEvents = {"_p_aruco__ScopedTimerEvents", "aruco::ScopedTimerEvents *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_aruco__Timer = {"_p_aruco__Timer", "aruco::Timer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__FileStorage = {"_p_cv__FileStorage", "cv::FileStorage *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__KeyPoint = {"_p_cv__KeyPoint", "cv::KeyPoint *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_cv__Point2f = {"_p_cv__Point2f", "std::vector< cv::Point2f >::value_type *|cv::Point2f *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_cv__Point3f = {"_p_cv__Point3f", "cv::Point3f *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__PtrT_aruco__FractalMarkerLabeler_t = {"_p_cv__PtrT_aruco__FractalMarkerLabeler_t", "cv::Ptr< aruco::FractalMarkerLabeler > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_cv__PtrT_aruco__MarkerDetector_t = {"_p_cv__PtrT_aruco__MarkerDetector_t", "cv::Ptr< aruco::MarkerDetector > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_cv__PtrT_aruco__MarkerLabeler_t = {"_p_cv__PtrT_aruco__MarkerLabeler_t", "cv::Ptr< aruco::MarkerLabeler > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_cv__Size = {"_p_cv__Size", "cv::Size *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; @@ -27860,16 +31168,23 @@ static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int static swig_type_info _swigt__p_std__chrono__high_resolution_clock__time_point = {"_p_std__chrono__high_resolution_clock__time_point", "std::chrono::high_resolution_clock::time_point *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__mapT_int_FractalMarker_t = {"_p_std__mapT_int_FractalMarker_t", "std::map< int,FractalMarker > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t = {"_p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t", "std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t", "std::map< int,std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__mapT_uint64_t_uint16_t_t = {"_p_std__mapT_uint64_t_uint16_t_t", "std::map< uint64_t,uint16_t > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__pairT_cv__Mat_cv__Mat_t = {"_p_std__pairT_cv__Mat_cv__Mat_t", "std::pair< cv::Mat,cv::Mat > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t = {"_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t", "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *|std::vector< aruco::Marker3DInfo > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t = {"_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t", "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t = {"_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t", "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t = {"_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t", "std::vector< cv::Mat,std::allocator< cv::Mat > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t = {"_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t", "std::vector< cv::Point2f > *|std::vector< cv::Point2f,std::allocator< cv::Point2f > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t = {"_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t", "std::vector< cv::Point3f,std::allocator< cv::Point3f > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t = {"_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t", "std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t = {"_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t", "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t = {"_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t", "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t = {"_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t", "std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0}; @@ -27882,13 +31197,20 @@ static swig_type_info _swigt__p_vectorT_cv__Point_t = {"_p_vectorT_cv__Point_t", static swig_type_info _swigt__p_vectorT_int_t = {"_p_vectorT_int_t", "vector< int > *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { + &_swigt__p_FractalMarker, + &_swigt__p_FractalMarkerSet, + &_swigt__p_FractalMarkerSet__CONF_TYPES, &_swigt__p_Marker, &_swigt__p_allocator_type, &_swigt__p_aruco__CameraParameters, &_swigt__p_aruco__CvDrawingUtils, &_swigt__p_aruco__Debug, &_swigt__p_aruco__Dictionary, - &_swigt__p_aruco__DictionaryBased, + &_swigt__p_aruco__FractalDetector, + &_swigt__p_aruco__FractalMarker, + &_swigt__p_aruco__FractalMarkerLabeler, + &_swigt__p_aruco__FractalMarkerSet, + &_swigt__p_aruco__FractalPoseTracker, &_swigt__p_aruco__Marker, &_swigt__p_aruco__Marker3DInfo, &_swigt__p_aruco__MarkerDetector, @@ -27897,17 +31219,22 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_aruco__MarkerMap, &_swigt__p_aruco__MarkerMapPoseTracker, &_swigt__p_aruco__MarkerPoseTracker, - &_swigt__p_aruco__SVMMarkers, + &_swigt__p_aruco__PicoFlann_KeyPointAdapter, &_swigt__p_aruco__ScopeTimer, &_swigt__p_aruco__ScopedTimerEvents, &_swigt__p_aruco__Timer, &_swigt__p_char, + &_swigt__p_cv__FileStorage, + &_swigt__p_cv__KeyPoint, &_swigt__p_cv__Point2f, &_swigt__p_cv__Point3f, + &_swigt__p_cv__PtrT_aruco__FractalMarkerLabeler_t, + &_swigt__p_cv__PtrT_aruco__MarkerDetector_t, &_swigt__p_cv__PtrT_aruco__MarkerLabeler_t, &_swigt__p_cv__Size, &_swigt__p_difference_type, &_swigt__p_double, + &_swigt__p_float, &_swigt__p_int, &_swigt__p_p_PyObject, &_swigt__p_size_type, @@ -27918,16 +31245,23 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_std__chrono__high_resolution_clock__time_point, &_swigt__p_std__invalid_argument, &_swigt__p_std__istream, + &_swigt__p_std__mapT_int_FractalMarker_t, + &_swigt__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, + &_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, &_swigt__p_std__mapT_uint64_t_uint16_t_t, &_swigt__p_std__ostream, &_swigt__p_std__pairT_cv__Mat_cv__Mat_t, &_swigt__p_std__string, &_swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, &_swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, + &_swigt__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, + &_swigt__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, &_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, &_swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, &_swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, + &_swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, + &_swigt__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, &_swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, &_swigt__p_swig__SwigPyIterator, @@ -27940,32 +31274,44 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_vectorT_int_t, }; +static swig_cast_info _swigc__p_FractalMarker[] = { {&_swigt__p_FractalMarker, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_FractalMarkerSet[] = { {&_swigt__p_FractalMarkerSet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_FractalMarkerSet__CONF_TYPES[] = { {&_swigt__p_FractalMarkerSet__CONF_TYPES, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_Marker[] = { {&_swigt__p_Marker, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__CameraParameters[] = { {&_swigt__p_aruco__CameraParameters, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__CvDrawingUtils[] = { {&_swigt__p_aruco__CvDrawingUtils, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__Debug[] = { {&_swigt__p_aruco__Debug, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__Dictionary[] = { {&_swigt__p_aruco__Dictionary, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__DictionaryBased[] = { {&_swigt__p_aruco__DictionaryBased, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__FractalDetector[] = { {&_swigt__p_aruco__FractalDetector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__FractalMarker[] = { {&_swigt__p_aruco__FractalMarker, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__FractalMarkerLabeler[] = { {&_swigt__p_aruco__FractalMarkerLabeler, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__FractalMarkerSet[] = { {&_swigt__p_aruco__FractalMarkerSet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__FractalPoseTracker[] = { {&_swigt__p_aruco__FractalPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__Marker[] = { {&_swigt__p_aruco__Marker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Marker3DInfo[] = { {&_swigt__p_aruco__Marker3DInfo, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__Marker3DInfo[] = { {&_swigt__p_aruco__FractalMarker, _p_aruco__FractalMarkerTo_p_aruco__Marker3DInfo, 0, 0}, {&_swigt__p_aruco__Marker3DInfo, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerDetector[] = { {&_swigt__p_aruco__MarkerDetector, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerDetector__Params[] = { {&_swigt__p_aruco__MarkerDetector__Params, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerLabeler[] = { {&_swigt__p_aruco__SVMMarkers, _p_aruco__SVMMarkersTo_p_aruco__MarkerLabeler, 0, 0}, {&_swigt__p_aruco__MarkerLabeler, 0, 0, 0}, {&_swigt__p_aruco__DictionaryBased, _p_aruco__DictionaryBasedTo_p_aruco__MarkerLabeler, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__MarkerLabeler[] = { {&_swigt__p_aruco__MarkerLabeler, 0, 0, 0}, {&_swigt__p_aruco__FractalMarkerLabeler, _p_aruco__FractalMarkerLabelerTo_p_aruco__MarkerLabeler, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerMap[] = { {&_swigt__p_aruco__MarkerMap, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerMapPoseTracker[] = { {&_swigt__p_aruco__MarkerMapPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__MarkerPoseTracker[] = { {&_swigt__p_aruco__MarkerPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__SVMMarkers[] = { {&_swigt__p_aruco__SVMMarkers, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_aruco__PicoFlann_KeyPointAdapter[] = { {&_swigt__p_aruco__PicoFlann_KeyPointAdapter, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__ScopeTimer[] = { {&_swigt__p_aruco__ScopeTimer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__ScopedTimerEvents[] = { {&_swigt__p_aruco__ScopedTimerEvents, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_aruco__Timer[] = { {&_swigt__p_aruco__Timer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__FileStorage[] = { {&_swigt__p_cv__FileStorage, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__KeyPoint[] = { {&_swigt__p_cv__KeyPoint, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_cv__Point2f[] = { {&_swigt__p_cv__Point2f, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_cv__Point3f[] = { {&_swigt__p_cv__Point3f, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__PtrT_aruco__FractalMarkerLabeler_t[] = { {&_swigt__p_cv__PtrT_aruco__FractalMarkerLabeler_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_cv__PtrT_aruco__MarkerDetector_t[] = { {&_swigt__p_cv__PtrT_aruco__MarkerDetector_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_cv__PtrT_aruco__MarkerLabeler_t[] = { {&_swigt__p_cv__PtrT_aruco__MarkerLabeler_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_cv__Size[] = { {&_swigt__p_cv__Size, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; @@ -27976,16 +31322,23 @@ static swig_cast_info _swigc__p_std__allocatorT_int_t[] = { {&_swigt__p_std__al static swig_cast_info _swigc__p_std__chrono__high_resolution_clock__time_point[] = { {&_swigt__p_std__chrono__high_resolution_clock__time_point, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__mapT_int_FractalMarker_t[] = { {&_swigt__p_std__mapT_int_FractalMarker_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t[] = { {&_swigt__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__mapT_uint64_t_uint16_t_t[] = { {&_swigt__p_std__mapT_uint64_t_uint16_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__pairT_cv__Mat_cv__Mat_t[] = { {&_swigt__p_std__pairT_cv__Mat_cv__Mat_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0, 0}, {&_swigt__p_aruco__MarkerMap, _p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t[] = { {&_swigt__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t[] = { {&_swigt__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t[] = { {&_swigt__p_aruco__Marker, _p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0}, {&_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t[] = { {&_swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t[] = { {&_swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t[] = { {&_swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = { {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}}; @@ -27998,13 +31351,20 @@ static swig_cast_info _swigc__p_vectorT_cv__Point_t[] = { {&_swigt__p_vectorT_c static swig_cast_info _swigc__p_vectorT_int_t[] = { {&_swigt__p_vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { + _swigc__p_FractalMarker, + _swigc__p_FractalMarkerSet, + _swigc__p_FractalMarkerSet__CONF_TYPES, _swigc__p_Marker, _swigc__p_allocator_type, _swigc__p_aruco__CameraParameters, _swigc__p_aruco__CvDrawingUtils, _swigc__p_aruco__Debug, _swigc__p_aruco__Dictionary, - _swigc__p_aruco__DictionaryBased, + _swigc__p_aruco__FractalDetector, + _swigc__p_aruco__FractalMarker, + _swigc__p_aruco__FractalMarkerLabeler, + _swigc__p_aruco__FractalMarkerSet, + _swigc__p_aruco__FractalPoseTracker, _swigc__p_aruco__Marker, _swigc__p_aruco__Marker3DInfo, _swigc__p_aruco__MarkerDetector, @@ -28013,17 +31373,22 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_aruco__MarkerMap, _swigc__p_aruco__MarkerMapPoseTracker, _swigc__p_aruco__MarkerPoseTracker, - _swigc__p_aruco__SVMMarkers, + _swigc__p_aruco__PicoFlann_KeyPointAdapter, _swigc__p_aruco__ScopeTimer, _swigc__p_aruco__ScopedTimerEvents, _swigc__p_aruco__Timer, _swigc__p_char, + _swigc__p_cv__FileStorage, + _swigc__p_cv__KeyPoint, _swigc__p_cv__Point2f, _swigc__p_cv__Point3f, + _swigc__p_cv__PtrT_aruco__FractalMarkerLabeler_t, + _swigc__p_cv__PtrT_aruco__MarkerDetector_t, _swigc__p_cv__PtrT_aruco__MarkerLabeler_t, _swigc__p_cv__Size, _swigc__p_difference_type, _swigc__p_double, + _swigc__p_float, _swigc__p_int, _swigc__p_p_PyObject, _swigc__p_size_type, @@ -28034,16 +31399,23 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_std__chrono__high_resolution_clock__time_point, _swigc__p_std__invalid_argument, _swigc__p_std__istream, + _swigc__p_std__mapT_int_FractalMarker_t, + _swigc__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, + _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, _swigc__p_std__mapT_uint64_t_uint16_t_t, _swigc__p_std__ostream, _swigc__p_std__pairT_cv__Mat_cv__Mat_t, _swigc__p_std__string, _swigc__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, _swigc__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, + _swigc__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, + _swigc__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, _swigc__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, _swigc__p_std__vectorT_int_std__allocatorT_int_t_t, _swigc__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, + _swigc__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, + _swigc__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, _swigc__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, _swigc__p_swig__SwigPyIterator, @@ -28773,6 +32145,15 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MarkerMap_NONE",SWIG_From_int(static_cast< int >(aruco::MarkerMap::NONE))); SWIG_Python_SetConstant(d, "MarkerMap_PIX",SWIG_From_int(static_cast< int >(aruco::MarkerMap::PIX))); SWIG_Python_SetConstant(d, "MarkerMap_METERS",SWIG_From_int(static_cast< int >(aruco::MarkerMap::METERS))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_2L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_2L_6))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_3L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_3L_6))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_4L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_4L_6))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_5L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_5L_6))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_CUSTOM",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::CUSTOM))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_NONE",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::NONE))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_PIX",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::PIX))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_METERS",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::METERS))); + SWIG_Python_SetConstant(d, "FractalMarkerSet_NORM",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::NORM))); SWIG_Python_SetConstant(d, "ScopeTimer_NSEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::NSEC))); SWIG_Python_SetConstant(d, "ScopeTimer_MSEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::MSEC))); SWIG_Python_SetConstant(d, "ScopeTimer_SEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::SEC))); diff --git a/build_wheel.sh b/build_wheel.sh index 2fa442c..1dae0cc 100755 --- a/build_wheel.sh +++ b/build_wheel.sh @@ -11,13 +11,13 @@ python setup.py sdist bdist_wheel python3 setup.py sdist bdist_wheel # create python2 env and run example -rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.0.13.0-cp27-cp27mu-linux_x86_64.whl && 27-sdist/bin/python example/example.py +rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.1.2.0-cp27-cp27mu-linux_x86_64.whl && 27-sdist/bin/python example/example.py # create python3 env and run example -rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.0.13.0-cp36-cp36m-linux_x86_64.whl && 36-sdist/bin/python example/example.py +rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.1.2.0-cp36-cp36m-linux_x86_64.whl && 36-sdist/bin/python example/example.py # test .tar.gz without wheel # create python2 env and run example -rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.0.13.0.tar.gz && 27-sdist/bin/python example/example.py +rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.1.2.0.tar.gz && 27-sdist/bin/python example/example.py # create python3 env and run example -rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.0.13.0.tar.gz && 36-sdist/bin/python example/example.py \ No newline at end of file +rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.1.2.0.tar.gz && 36-sdist/bin/python example/example.py \ No newline at end of file diff --git a/example/example.py b/example/example.py index a9efba0..c4bbb68 100644 --- a/example/example.py +++ b/example/example.py @@ -3,9 +3,9 @@ import cv2 import numpy as np import aruco +import pkg_resources # part of setuptools if __name__ == '__main__': - # load board and camera parameters #boardconfig = aruco.BoardConfiguration("chessboardinfo_small_meters.yml") camparam = aruco.CameraParameters() @@ -42,8 +42,18 @@ # calculate marker extrinsics for marker size of 3.5cm marker.calculateExtrinsics(0.035, camparam) # print("Marker extrinsics:\n{}\n{}".format(marker.Tvec, marker.Rvec)) + aruco.CvDrawingUtils.draw3dAxis(frame, camparam, marker.Rvec, marker.Tvec, .1) print("detected ids: {}".format(", ".join(str(m.id) for m in markers))) + # add aruco version to frame + y, x, c = frame.shape + text = "aruco {}".format(pkg_resources.require("aruco")[0].version) + font = cv2.FONT_HERSHEY_PLAIN + font_scale = 2 + thickness = 2 + cv2.putText(frame, text, (15, y - 15), font, font_scale, (255, 255, 255), thickness, + cv2.LINE_AA) + # show frame cv2.imshow("frame", frame) cv2.waitKey(100) diff --git a/example/fractal.png b/example/fractal.png new file mode 100644 index 0000000000000000000000000000000000000000..7545bd0da332b8646ff4bfd5a18853fecec92180 GIT binary patch literal 31030 zcmeHQe@s(X6z(#O@Q@5=K_E^EEm#UTpk#4z3!~C!A9IA(VnvXNksl^gn36F>T|(%R zL7D3tU2KL-ewYy(i?Rg-0kzWzq(Q>=j}awAY-C%&2nmA_-MP09C@xEuZ4t%u$4lD# zZf{@DJLfy!`EK*h7s*Lmy_rBpBocXZ>IAJwbkNeG6BnlF73Gup5U-|v& zRqvmoM6X`>`SBL3M0!GG9+GUAa(wj}H7|YleUp?s@=Y+uPeiDA=}2mslM)`-MZv6O4mr&cz} z)OlPpW~m2@N{OVd*u#PxUd)ZzkY1M~xog+;}KPQ9N&rD{{{)Dht7pX{kU-=J>s zD5s%0oslZ`^BwWa)KC-~3@^9W2Hy#epkOyroTb^Rt4}LcQAj)17{Qd66_lTEAjnrg zW>#ftOb1u_QGlH2Xp%+9`y=hO6bA82(Y)wLK^QU!4v4++m}M}Z&NBxf3_v%;1fXm&|gJ5nK{&sil5_ zPK42euz`3<(+MUD%#cV8kQyL0coB&;@P7Vr*c|Z(#$W&0JmoKF4j%b#u6}^ur=I?P zu5!SS&Q?ZfCZU)_m-u^^NH}QwWA?uQ7)4|Q1HncRW?mLxoxZSQMa!yX@hh*Lee~L{ zq|9~RJBxh+0s{iOkEWfpJdsu?CHuwr7OnB`ouQo>Ps|=Q6orh-V`F0ZB44N3G2k_x z=uFAomn$8YJHjokYhcXU*VU(XrkvEr9DWnV^fjg$lfxR-xX+mZV~tA57KuflnbGa& zfUyh%`#BraXm95&#W2>+RIIFk!J-hwB#agL5|_m3qyiByFD*>W!VhFhi3Ifuz!Oh;TQv|!+Stt#{O_D-_ z{()RwpE_`kR8sKI8BQX|P6{A6E09wP>_f%@Pe?Ag^W_oYn)FsynKqNeQBkj&kk5{mLSBmHS$bBWvNSCT*Uk3J=vfyfrYXlB(7GDZ9=&Wh zD^P3vQFy1&{U9zdrl594pg>4pLV4=ZZCa^yKb`bunrU73mkfG2l2&0)<6(E67cC8+ z&h5B7(bv#8AS0mXfOd#s1!^>c0)m22kS!7@nETXJbet~_L6yw=I=se21xnaMIY9PG zKx;g3C?uArvSY=*&PY-cvYDM9*h*Qdc|z^jLg*04mo44%i%vC@iYd@A^;YZaf!$O_ zWn%{YU<6Mw|@Is$Ii%#BHw|0Q_Sr+XRet-RsRmyu&Cw6VwSG2+37xMlNqt;lWfxF#U znPZRB-}Pj#18wlF6W8t0Id9v;?^_<;G#8d=qJec>mtB|no2Qx|CKiRx9KL^QkIra6 zniicH&9GUWk?q=Q&nM})EE)kl;l&RJd%C%mQC^qH%sF<&EF?tfvuq{F(M%$s!nRpN zaHLqQK{{iJwkY(S?X!SzIK?UV@U1(otMyyB(60~_5EK?QowPDUd2QD_<)F(_^_9Gc8qcs;L1(2REqP&g6oUq%ab+^{ zf>DftQUjkQ+AJnG~SU!+HI19&R@<@5tgWuYiHhCK}ok!YJ&}YAu*-C71JWeCsEa;Qt za2d1>`V9sH0tJHT|D74s{De(t`nFqW`gTcZcvdKMjT;lX#@!XV#&rl?r)XZYHV7J8nKVR1^06iJFg#-YDxB()15SSix z{T<*001yeGw*OW5e_tRXFfj=!gp8bml8~W>4j=-7!9>Jh5)xu!Lhe99IzUWM!f;De ziIh>#3c~FH6$^>WCgXWf(aNMhxWg-M?HNi=apNX43+rt@egQ!t2}vnw8Cki9kCatZ z)zmc%42_IUOrMz9*xK1UIHH`qykGjf^7Zo%3y+9=^Y$GkJ|QtFIVJT&+NYdcd|rM* zVNqpObxmzueZ!Zw_U|2?UEM!=hK5H*$HpgqPyU@>SX^3O`M0{ZySIOEcyxSndiEbK z5CP}^dHpY7{|{XB1YAVK#9(5`f4D$IuLxf-Ju%5GQBnpaJ&2VDBez%x8T3J1c10^W zkGTF0leOm{#SLDGzqfb)gZ4kj{@(!${r`pR{{r@ZB}07H<|{KW&cw z=-`qYYluci+2_cGYhFCuFEf0`IFjbxz2!boE}>VamUdFr(_at&;z+roOXLV9mf-mn>d(qQd$Am@!50Y5?P#82G^ zy;E!%)_E7370<%9^Xab*9y>!v1=8Qto5C!ad>4nsxm^Q+Qi3bb)7^v_u6VD3h?`8< zEKlq~$ao=_3H$xG8EDoRT#c1Z~w8A`JpcH~ltZ(giLaNUl9pQmEY&A6vwb9lT zecUiVla$cM-@k$#g5`9%KeOc;!WKv8S^ikEumkLCY__dpK1^QPnF6kl5`@L(Vwo@* z3t^oCEDDOSh7X#TsfBPR>=2rEw@81rm?~1%+SY3Hd8n|*p{Cz`uKL@}o&bf(t%@~G zhbE&DH=eI?tkQ9zWr|)2S#C~5%X*dJv|rG2N)F^#jF^ggpXK1d4kGSzViJGYrQnq$p`U&ZB?xC zvGGiAZtI*bC--e>O3pC4xO{yD>gMRG(KsvpX|CzU8>zO~DzxH5_D?k%N9FUmmYpu_ zFqiHj8&N?6yU?p3aa~bF1QBewRRoxyPXDE zGX~xEh9vIbpClo9>BErX0;^*!m+hxR_+0v0BT`kbUM+1M4J&>b9P*bMS3=k%t~PS) zFFtzkb%#w0^Ma(HOo7Bw@2?^MmD2&S*)06jvo%epU;#g4k?#(!9tp<7$coIBjR7@Q zeT||oOw+2CN(!TQ)sS*i(u zU@s*WtLmad$i#$HthF5>t6C(yOhTR})1xw6Rhdt?y@`}Iz1hYAwx4t&7PP zLENze=jLor+@fxg4y`pPEGV#!e%ZN<{;EZ~y!XRmQ=f)LUJ9+zUF(C{GI_>gK^I82 zZ9Mxb&G^;r5AUo4)p3t(bgFq$yOvR_b}ynEY;;xq-CYG+W1v)CDkWdlx+Oo7H04%l zGIoNCIbDUW<{#@tcob^PWyGug6QF0Vs*7J*hz7NjfZ^(;QaekP7By9URR7%93VuPc zWW4@?!XgYQ1`As%K}-w{5+q$;atiguzC{*vkd*XuOE|GGhs9`* z1{%D&J!&$FCDDCn^zun<{jD$b13QSb0}xqVZM=`#I0f@Pb+~$mQ**?IO%s!nLD|xO#b)ZP>|i` zrzD>*ksOCmyl3g zZRqmLN4Jb}$r~!&$=Ad(&kY! zqmwotm=c-X3UCyfb~JvF{o=SsZ*ljDinphyg2DW_LcM+sqQ&@0Wf9(jyX!{OADa`J zLYU7dB>l`WMTU$D{Mm~^5+prGK9m7oRP=PE!Y=wZq8=$myXJaXTS2k|J-cPoBp5Pm?d!OVh>93U(l zO0yc#En$0?w51>~Ie9~a%*UnzC0}*8bEpCg-+Dw1+~kVy5shR4GFUO@k777wf5-r1 zA@WHnO!}LzR7wX*L7rqKvkn4p?*0y_H~=@~_gWt9r7oR5^)L6>2&6U}c4O$-lh5He zGO{kxCf%STKjU!foyAjMemVV2T(2e69sW0Euu?}`#F6sDKwCwuDz7KCqS~YBSkNJk z(!?6w-C|i`mmD{?f=K3ji>rriGH}+ptPw)*(atiX6 ze!PTv=7#Wd&AQ0HTRds|8-vxa=`S33fO7}Z;^*xoO$USK+V=05i`3BX+5b^Sg-S*- zEv}R*-!7`Stqm_+`(x&7{TSq#gWN6K@dT}~7q-?31m$O+jdrmRbAFj-&HbQG<&b?9 zSQy;6f_a9L?dQ&*eh9Fm+R|j!wILEf&REH#6CP|MYncqYxIUk>SH`O%CC`PjC0W=} zQ45FCxQI1Rkw`t5Pe}u0;017a!Ey>rSAuKxOm9GcUm0Lo z!1Rr?xkh_z;eu=_1{G6FV(7p1-cC9HReW|092T(j(Wi#ew%1wEGK*4<3hDODL=diS&2~y+&O!w?AyOyukZ!DMP){A7=Mh0rB4@C_M4#kyrT}2 ziVU?7b!NCwJ5e~cI&}aypLnpU1(C2l3*w92lIMytP+O73FTnI!Nkz^L#j+7%8FAf( zA8N}23~BF;IB*4%I)aPg1(SiOMGEaO{0m!Y7uaz=O=A55l*&y*Mgij^&{axgBZ!*F zVcyiTK`w`WJJ^92BH33#bk9&7O8R8o+?ghv8d@)Lw31^kE*p~MHp%++@`;uSVMCQ^ zTNCb|R4zoHh0L?_vDIS##yv@N;l<7rvv{W(d=dap;v=von^C^l-|6dV`p0{gydd$X zj>Eb>g`}D9C*Oy31}5kRm6=Q!M5cJQuf$=Ut8SOK`*2uQi=unXhQ<&KEbTvFhI7Br5(Ww)HjUu2h{WMAnU?upuepaKumwLD2s9K!-xn7Je z5`Tt~g$o9QC(>RiMGb*gHM7is2Oj;dhaZHuJUh#OO(dr-+W`9bPaqnzYu&p zQznyv{=-)lkuNjrWGZox8p{WSg^D6?L?3?U42&5>oE@@^+}%I6wK}0NJ$SnRf*~_3 z!+-S6&hFc*-H%=~ktBfq)2DY^Dc%}_rx!<8IlG77cy+)f>a8t*PpcNrmuP%aI}!^; zBmqW`^(P8wDg}?)(GluLUsYfh!RSd9LOt`&JZ)o_Kiv?rH@)b^M=D8x0`avxSBg0o zOwDbd{5DOlo>8K|yg8fCak(8UC>GWbyh?!gm*cW4gQc-)>Xp0Sfnp-)K|q0)R$TE7 zS7~YH3!%|61MRrCSBw`$Dm$kUdW(0MB29SMB238`xPtFZ+dx5C&V|ZU4`gj##LOF9 z3QexvxQ8B>y9OHHoY@yY&gaFNidq~M?U~+ju5V~j*hNP3c-iaRbW|+*bMaVZT*{_& zD9cU-@r$BN!luqQgQ?RClRT{C+<523uccQm#I~1kN9OV78Y6jyad>66>b}G#SMn1! zcGN=q2DdoFm459|S4fsd6)~k7^CJof+CYoyXTZO?d+|9UcVm0dc#FpmIx0RqMa*hl z1Kg;p)j{o!b{ECbCkMGkylU#}8052?KB`yG=>qkdPtqRxS?3^7)K_cLheQSKc=CCZ zC!J)g*hIcWmfs3P8nv^KX9DzAhnhy`g~FHa%?s*z4QckTEh~7hl4N!oPg|deUrtm1 zNij>F9dscbfgSgo0lm_i&aVXGD2q9|hz)nwZrFO-8Ege#13U&6tGm;+`+Ido$3Usfs$7&pac47aaFNUAM(QY+$sz`p?F(V^16xLd5k` z2#c5Y=jUp?4|-7%;ZbXCma1EGFoau^L-K}7` zspqk!x(|(?QG(quo|m#3RN_bA4dnDcOx{im1$cPMpYPMb)}{%zltc9VocVB`Y&$(9qLs;OD{+KTZ~yvW&p%-4ygF zZSJ?s>dHalQ0kXTIjJ;ENwAh)oeM|{)u*0)*1 zSXHE>dAeuN`TbF^i=vTTRZr60P&qoMx+7iJcvt`iNY$YsoqBr>%pr#(z6<%)zvpNf zH5odp6iC^Ic?$9lQ>i`0Gjoi9+}Cat5B_dSLU-acYcfwYvcYUB{v&#;29KffpQ?C$ zXL}kbv&?Ex*6VCPVUM|DNYWvchX>n8CRbCX*H2PBGjs5g4q>AyYvLyS5%)wJEwSOO zWfC1W?Quw=ACTv=XgYLTE@Mj$pWOwBupERwmHr95BPR~_grh1^rK~qmHvxZLk{q;a z6HEF(A(^sd=f?21%7p}@vF}ykwDD@-TCbr}e0J4`oH!5e3_3L#L!=8dk5xEvF`gkm~#5*|-Pgn#I&5j{9k zzGJIP!gYtTp680YYeJ7|RbmUcrM7MOt-pV^xEO5u%O*{%vRrpYMHw*aX;r|?B`Id% zg??}z?;bKKbSGrQMIJJdRZtJ^9^%NE2Cf0tEAMMS5?C6K@ekRcD0{e)rux}i|JNF@ zu0_e|{7&^x|4`ghS7T+C4t){23I4reccDjO4L_JAg3B4Xi+RICX?r}hNpw^V&I~JC zVbS%rjH|loQv6GnLDjULhCD3O2)S6XW2@6q8wa6eB=?>&!ujoyx-GZgA zzk2mgHs3uf9x6)rfg~4uxV%$i;W{6Hli7HSTBSSR*TQ}ZR@$OwXesH4jmzx(BqH)p z`Ie)WVC!f9n7(2^oi&7<&h5))IiikXF%nsig96u^OAOe{wcFuaY;TFmxO8|`eyMc; zN)0UFZMO45Xh_OPkavtrsD_m43(VWLg<6y;`5xSHLGt;}STuQ#%^B+*5?srxe27v; ztx#6-Rb<93ud!6q!HCw=knVp@?E*Z+9R5baMtkj~mR=_G$3#tCWu*Crit<0o;Yg%H$*h|O3BEuLf@bYjb|f49 z#}V^YR}lm@>uJ|j=tyc@iaq$bIqlK->9}1ih^0*K`|{N|=O3ouK8lI4znWZkCRfX= z|1O^1++9Q88HduCtaiAZL~i$gqbr{dw^{2dKVW))Y(6p2;!GqvpW_sV^}kAN6CVpP zeY+z%-bB`6O6Mrs%hkQAJ?HKJv>%-5Z-Uf5X$M&tMJ@4yE6OT6(PHr2Ar^sdJS13< znTfxYMRpTOGqkzn zQptlZ?S_tChb4We5-bd}>N9rtK+)(2m-{qE%TBkU-wEjV*M*}3Mu2n`QI$c>7!6S* zHP65hy*BrMG-kj6WI<@_UCX?tg=AG}owS43%y0!*^q{LpDjOM`x* z1inHB5%AZvS759%bN33gzNJHik(r-(K6XKt9p$s4Fsw6-0ZM&VmY#nfHDt@vI~iUH z9IBP05vb!7m;FaVbbDH1UWdyAGov|?uA^M*>%vdF%3}?8N4*6vRXzS}98h_>8jl*v#_-t-u`yHDGoBh8bbR-e%@sFm)k=9B-EcRg z>2srh+Stc3m(m%kI8`<(rgt>V=%%Qknh5KuO{M3liz~2w6W6>4OSf*@OyaOeUQoR1 zxCBUVYFHASkg0yLrphymyB(vH2H1R~^)D2X7#0cz5tXGrk8gK8w5blN(HG&=1El8i z3$`)9Xkr5V%OT4hw9x3VTYR6Vy^h!oW0M#la$%`k@eOH(nIUWFJ9a~omOJjU#o2`Q zziiH*X)!1fSWhp!$1A3>^zloA5hbTtT>E`p)v-^la8gIQq3>BvrLV5CD@J04R^oVw z9!SAG4BbB55J?|R{ruNl=4?Lr4&RA)q(#O8%URms=QLr@7;cFOq)>Kk^vt{Mi(
  • x0Z9Dj&_51Z3fnCq8YEsQ7lLp7- z3Es1)UY3?F5rf=8o-CU-txVwqdH1)y2P_5odK5R}lC)`7b`AoISx(X;0x>kGnp4<7yX}m1iW~CqQ=iER4iE&jw#*s^VsDBOXkgo4SX!u5|Je@MV@52M$ z$5EYtuK{OqEQpx1+n|+4H(hq~qLAxWc}6iQ+ZU|T+)#Xu{>wW>PgJB~;7w%o`dxkI zzdF@zw#n05b*^MAS2qrI{WzoblV2r2*b}w4iP!O3*JIArC07BD!}MtyqYPLC(Ed-S zhgIRSg+#I}WZ(T4Fi5+ZVl)c5fCIAn;#)xT@avQ;$ zbn!^)R{khm(u*5Ml_)6&vWIFtZI5G1-rS1eUncgz^p3gQEj_%UmZXqp^itQ;kbba< z#;fbaDEZynQFb{l`8hURSCY)e2Hg@Qzr~aR*}d_-Vhtn=6ysD7zK}7p8|qI1s$_pu zms}>sV$L;Ki2iv45i%I{SSu|@T0X5aT#j-`aYeb5@- zXVcDVnnR|rYDfuuWar#5@s*L!g42}Zew~miKhvYD zeJ!v;$VD{Zh%&1m-Ygq-zVX2*Ay{S3k9x!Kb8*Gmk@0T2udz{W60cYx5c{iMS9b9} zGyljq+%@`+hHkOQT$$fRvBu?QzWupm&I49s_g{Xk;H4HApb8t{PW#a>TR2#ydnagA z!clc60ZEhL780zmfGK|UVMDKVB@|uy)U%@So{Yx27x|Y?GIE1vyCNs*!`m zfliH+i$#-H`Ng_!rQP-s`0A5k84CC9UwGm(Ct>$Wzz)v5fY8YL=`pIagrq1@Vp+~t z?H|iV%40qtyStpMZ(FkR>B?d7?yQ=Uva-y5fkiu9_jD+y(~1*gwJ=H+N5{E01PbMu z-VBw__6)zx3rI>o$y;Al-tny=#4mQCi> zEh%HobV#8!3KasEPypZI9^)tj1`2N z>R?_ey{972ih?K%2$L}53<^NG0n3Rr0+Ru{kV2fLuY$uaetj$fmrrFQK@#5gM+0m- z6in;%wEmv}K+&{rJ=xc%DK<#j@P)Er!O~Emo7sXx2d=YZda)9sFYLnpj~L}7_u_`n zXDwF4WV^eIm5cXiXccVsibO@3T`$Rw3Vx;`PhKP-Z$1%gHY=_}abXXw87Pu$_9LU`EUJVUGuxNxy#T5=ZC(9tA7N_kY^rPU+ z`EvU3E)J5zjhrs1Pl6)%FfP(``SK&MVfTw6LY$0nA?4! zVSQp0Th0UC_7B5mjy9y<)hBrG+jnz_tGfZ>tn}eht*El>ktI`GPA3peCrYrzLv=xo zbUp=IKOdzl3gA1K@tk;oA4((G;w=#l8vtRw3~L0WTVOPXS4po!w7hBXIuAr2j?lP! zbjU+jqH-h1S`9E-*4a@=nQawn8Em3W8d9X(|KX}mryyA`AP%+8!T^W3JK_*12Z_Rb zsO%B$p{R=Na@L9dOB@v^^cmY@4rMB^mJe+{dN`)DadaYH{je;*^VRIjvnjz-D`vzt zht2_0Pr|lgcxR?x7xcrXY91{#_tlRgy5U%vD?_i@#8)}+0+1}bldSg09a=8K{ITMv zB8K2HN1_nfACjIjK2suht7Dz=#9F9q)0%}Yzq12Ba8zTV$_hYGWUOD02qkTHS>#iJ z+@BQP<@XPE#dS32`=!hrw%!iWnmZ;$V zYKscO{{8fbFT?69`fpP6Y%kv&nA2&fqQUR(#5cuf;%Zc*RT&i|$ip9{0#@{9smD>V zerKaolzQH5_vO{WJX()jy0{F}?Am)uq6a;~kW?dgGM{L6?ZaqD z94<3g*|-IvF-qoRm42BvSg}RgwvwW%&&n26biknmsQ2Cd0ZYl23$rkfApfSW<XTxM9nMB- zkHmj1a0x&%G6@b@0=SS#Lo+#aO&Uqd%rlV&G`(`=7*VaK3aW`3dnNFlEOnutrSxmc z>0cd_nNx~^+FJ3>-X_C6Cex^jPIuXBKo&=1^z7;$Q~q;HvyVqjs#pHgK`u{)%|wEK zJ@qxRu9rQ12R=2jZVMJ+)m-WJ`53a%QTWbHzLtn1AX6A;|6_HiXj+jg;c^&xa^501 zQ#9gS<>F=L^Y3FZahvLkE47Ybnb|*e7j@}7)`F4p4Sl9+vm1XF%&e)rp?>`A0-!H1 zs~#pN27ARygVoWt!|LDojQK+;LE7i?)-hFe{y;z7Y)g=G9D2rWC!exZ3B8ni4HOo) zO`i`~cPg3zpIi?~uYu%*D_cW*`5*m#x8084UDaeSW{&)2>DK^CQFa0;Vg*K>a#5q} zQ#Kw98+IiAL@46ddP|=Vaa5z2E80VQW$=0Q6?D0ABxU<1Vw(#wRGz4qIP^vWq~^pL zDKm2o1a+P02Uh7N1nx{$KCy9H%^>+DQ;Bzc~i~se1OF7&XS6}d&?_*!H_MUzh=s3qQ$=a zd5*2@1w`eOuGhdyZq|pq4`mjXjrqHhzV}o-w8=M-ETOWdmqS4{#Wv*8Y`k<6-8khA zE;OGdSx+5gVt~XvorV5G0*QM6GpEn{!+CS?Dl=(=q%YC5GwY|j2BwpjMaBl)olx5< zckv7mlI5Apcu7|2{dAvc@cqAO(>L^Um46u78Q*Er>1mw`Nz+NBkMbYOjjLv;cJ2AqmWw=y80xyjk_Otz9jNDs`*kNbTU=k>DG`iS`zteG!(f1q{)$r8M~b;AeAVLwdGMIdD27BUVS@}X*rj}a5-KPE@i{wRb$BBxWc=_4qQ4?W}ISPAv|LK8kchU zX2^%;WRuqNR|V+iR#u7-Gp&S*iLV|MXtQX`niAQ_J>{NiDY`UPJ{htnbI- z^8P-rhv5RZvPFhhbs7+?E^?UDn{n*cQ;Ur+`dRx|qe6(Bd4)LSWIq1xJ#`kN+wXaA zZFzjncb(~1LRxex2JA*kT2Hbtwb%7PEJj1|upH`=++y$qCN^-|2Y1i7zFMsIU-z_s zj9J0hP`MH3N0h5=c(7OxjZjlniaxVvz6^XHX_3D~P*8?m#QI1MYw{(|&GS7_<8eA5 z_C$bBcJ+>1@g_TrqM&xSeLXh&u7J{P2L!9?#ry=YT#j9K5FkMIE`dPpiU5mzdf|6B zGb;ZucVtU(ut2RnHs9$Iaw^fWJYf@ti5Mw~&>`kPanaeZbdDZg znV55x9Q&j zUMHnQ{tDEna!I%=75VeT8=Su2!*#Q642FpmN(IPK_;hRtB3p0()xeDuXwGCXBS&It zhm4ns=wvXReXyWT6T2hO!Tv>8Am7SDjzXqS5IK((r1~*pH6`LMV|6yFWoupQ#-Nsb>9|hL28HsULrMcd=GB zBtQJ)2XE%L>h{ATwYYGbKVvCzTY~PSs%Eqt^+f=f*FK?H;%{hur=Zk6wi*bw^$Ig| zV@{b`T{VM&;(begr+ZaE!nDXXQv!R=1bUxNK2x#kh8f;K@_K5h1Pb12CZqUrV?~xU zma)Nos*WzuOSi!uR`+>1({(eexH99FS=3L^s@OH~hcAS#GS+`Yb={b9D%MNz0-6@p zREZ^yIc&QIqQSRpA}*XYcxt=7N$LsG&PThX2ROYJ3Ub-v@$yQU9UN>0oDT&#N!zZ* zoebdNY>OjEL46U@DI6raRasi~d|Uh$>5ZYJ);H=lpMzt;=!=D$!~#nf5)Ojc!z zhUr2nK9$%t6eY{6QGSM-Ezr!xh$ zZc7O78()~M)bK^L#be_iZxsDGy{Ql%fmh8tsb=sIu^%>KMZ#2f+c~u19@|g8@s5{D z`nn8F%D=s+wYL&ZCXN-2Nj)DIzRa;lFI5GJX6@$H=Gb9vlbVu6FCPO8E4xL_{-?UZ zo&Y{UzwTeGd_Yym8R!y~9MATCXX!y^Jv#~DXu)|Y)XMf;rdXBmHdwv;vo;x69hUFLPuo}5Eg z+0YSyLc+Symd=^{%22NK7yp>Us)hs8V9pP2tA=GYWXn4D1T?7jex1L&Bo&~~b}gzE zqYv53xH3|Vaaoz-wx#}sl2mK-5?L{QsLSqol_nig30&`5)V(Q=8-Uj%N24-3uISRzr*?b1Esp*}n)$Lxyn6E*c+Cn})hZ_bsXRBh25JxbPdEM? zx8`0=4%0sAz6OFN0g=f?@4U;z1-!<~==)azS?7P7+Y;AV-7bz1#{|8ai%Y6`V<<3v zGXH9PSm&aSu*&M3=%bxiao0dO;`k?_BTS^ahSFSOtc=k$2ZPtZ-R9k4rO|`!(+%`? z*cB9HI$5##_*~dV-s#WLw~yBVT<3BJg{V2$u<1n{x8{-PRMvT5s0$C4OFll=xdt-x zuTCU}i&w9K{lVt#Ff}sj>@7jX?f{Cc^Jnc>{?eCwsC<*pSLX!jK7{_gJ|Z&n?vA^% z;OK_v@t>=cJVF(inyjz`vNlX1ZPOAUca?ooe?V41O=u z^wunQ;6+RY+PkJ!pok6%KI~QgdT9Pn^aPd31>F zva-c-FFFu&`V+Oc)5-1XE8mHe`Ztq!4fvT7G}Z#w_Z)iYIR*XqNt|tHf({mMT4C*} z{)4|sEqtZa@Z1a(9T`)*@F~bXxFR6>H=LHVpr_x>)08$TQt?y5X1pjf0C;sgPa3tl z*G<;xfrKiK_disf+#g}pHyX4MAl~sUEmROJ=*m$oOdaUp0SfZ(hRS8O1XY9H9F-U5 z-js#Y4rTn)`@jxx&0&y5v@=l9onXxuFdrDkiBoJ^n&o-orMzLRSmcC>kgAS<$-jze zDDNg*z)}GtwNRMn=bU*>FisDfLW`}K# z6#XUjyL&o7)JIY8@u!JLyJYE$?MjHT^~68D&N(5_l0pZOOFvk#y2UZcYb-(m>wN`1Yx^?L3EyMk8yeFjwdo)Kk4>xvZ&i@^vZ6FIvV!q4iL7X8|Shjjl&) z0q2r6*@ZH_2$cyxyRy2_w*E}l9`2DsW@7s?>0Fe*K~qb?jK#;P9YWx{h3@S`vpCR# zOfQo7&6OE#Ps)p?T*%I+_6EzBW&161D@o$0s&5PrQ;#{KS5FA>E&GS}@~Qj}xJ#xi z6c~Bmc05tDR9e*^;0xF}&iNym@ORTnl3=HUJ%pkw%X4V1ff%zf@K|HiS>`=7@ zKarBB2wgB_RH^MB4KnIqGH|zZcNaiE8==+G?OH-;;J95+3sTuz!p3s>u}O?Cam2Fh ztF+u1GzJO1w~3hjch#eg^I0EaFHvv3we&&`%F;C({&|fxSh{Nq>u6^=1KNTi;~LWU zc3UKGu4vcBYLe0_80Zl14}}IF!UhM9@)G*ZM8q>ALo7D@en9mHv2tVKZ{_y2q0?U4 z5In$M7@)7e5~WK-f2xN?Ir5|dTK@VWnks_tqM=)khxkooD3qpuFM(^Zg2~Arrq*)lH7kg299P4P58RN6xVFk%p^7XA_skzWxohGD(9+? z%dhuisr==sQ&^;y{6Hy(Q^R7Rlo)&XfLVz>8X`NN64%-bWc_Rs0p#>;Fc#pjURX#U z3dGdD5fS6nQqsvQDCvKEzXlSdR?zW<_*S3#_A2t-=BFuFXt`dm=)u3~c(G;;PwnpP zpdjGXxy9j)YBQ307i!H#x8EX@Ub!e z?^}_-wBqNXtY%FkZbFXd>zOOs1=+xm0FG z9ZQck19C1S|Lo78x3jLAWE`K>fjJ2FdAvAu?}6gl!Y=;YCamrLvLjK!z&xkF2||ma z&LzM7#qTKg8EKBkT#bSGi)IgfPC2<3n)y;0ES@NPaa=; zLyitF1IphzhDs-#yZD=xK86=DCj%r_fA>@`UdNoT5bU$+5x|q4@IUWen`lhQn;--- zT}d>*NEk#Aep_?VLeGNQ|IU$JXtAuJ0Ving% z6M_~#<*#2!pdA(ExbjGBaOmOwD}vWEo^uY^q-R|ao+~$|!7T=k5W4)n9S@sL|H73- zaOq{R{B+j&0wGmt0Q#~4aoj~Hx|HqrgLry!PO}opHzY~f$o2}pV8(Njfa$DO^w~l4 zgka3cDdM=FkTX*6N7AjCMdLVvdlN=>CQ& zdZi>Q|3uf@G~g#8C)52&emLtbLSz_XLG$Qc_xa$;xD_FI1_(Q6fT2shPW9Pua3RK; z2{~o!v%V5q;C0q6Zd&Je!qq8a0m*a?R9GSQM)yzjuL0{0f`|3|pzz|fxv}~92cZ;_ z?=35y=>Pf{DDn1fCa_(2>2nSRbcxkrhncvBDoykMv{ag13TGgCI}IrF4(Hq(Y}UA` z`N(~0DlBu<=GXs9LB&7cF2CGIGUO_$K(uS1$#k+mv>3-x9k(){eRzJpoE=b@7?#8y z^WU7p0jnO2?P4)rdLKo_zrW$s$oMG>`|@8?p)ze}r0@UFDu5%q2CAShW7E(_FSz!8 zp;@1c>0LMz&=DrXKe1nOm4p!|0aEbDb&g2!=I<2zpyUpKl~^>=;V6WjQv`2La> ziHqWNRHW6(h=XRLf1z=#~iVly-&O=Soxqkuo#fV@zo2Jf=4QPc zmoQ@FR{1l-WjO@feF(+Hm^u8myV|_}`}Wm8!p_LZ4kG^sTBpHI{2mJz0y*DvH(~M= zFh$zD=J3TS+gbjIcUL9-$W|%xGO#3{D=btPhUungH-} z@;hi8FHx{1^y=wg#vu$-rb3w39adjyeDRdnoWpzukAEnst?o5Jl5id&WjGtp^vhf! z)fxd7*)5c*<7y*k8A0kJ=RxQ6?$yJaSev|IQ7d836$>Z**4Lj^%msR#YigbI_NTwM zyt%AUd4zbQ)03xGP*r3%Ez@C`$n@f- zrdM;2%@gD{jnRucHIXcej6AJq>2of67t~*-9q!&|>M*c>=}i0Grv&?)^HrFd^_2Q@ zTY1K!!Jl%;54qZ=>Xe*c_XQB8sD=#zdV0k!X#04L%yFKlzX2#GveOrVCw{q{@v~D! zOcqL;9)}?oU+)xbbhtn*`VV_NCPQ&F6`8_vgO@+a{J?RhTBox6d~jEM=B)Cv-4znn z>v?8-VoAPeVnlg5b}~m0`H-^f8lorqbV}=*XG4}g4~GwPxv{g=%`1`x;mmlzIx2ud zF*Fq*`iRjE6!hzt2nJT5HbW^;8%PbnwW=Y&oe0V@Be4=iLUV2K%(y#z0vs1ZmncWN zK@4Opg$R29RlVcP&Ey(cX&>Hx%izSgSJ?yjAmVE^Fyu&OqaHPaB}7$4(XZ<*WEfTi zLj&|fFtqDxqzgk~LmA2vJ8(yE(r)QB5SM?u03p$v@IUhC!d^Lib+YclJm9Fw$>^Ce z=S)m{`FdIluS0#&qYCnVZ9%eQT!u}?;HKfNTn0FS_uA|r_L@xr!yW(AR>yE4EJ}4K zlx!UXgd)MoJbc;m=`y`fg>;;Vup=$~WNo3P*vRVIkW5GoNJRzN!6p76VPe4WfT-Fd zY+@*arH{ZEWPLtk)k){)8jI7*42{l_?Ldj{x*xNAn@uCO!qsEfOxzw+2XfCMcv93X1W- z3Wg%oD}+GoV$AC413+rJ{uDs*LC5`PH4fGbbxRub=r0H%pg@%!C1*7AK8En;aq;CK z5?ZC1aW>i%ob?6rSHnhUD@=>RJBN4IxQ7cS0DbYSg#u}`I$WyvLGx+hhOk9v{rRUN zvZNY@dgg-*0Z=fN!J8TsrEk|xOi#w$g^l;8dhQizka?6yz*u1@Vhcbigd+%t?t~+v za@4d*oKkrpY!Hr-z)VH4(2s4M!WEmk@=~&r1L>wZJ9kAl{=(@|7I(ZNRr5|upMoka zY`F=`qa;gBr&=_@q-y`Qq0{)itzS|)F;-CLx=XMe+UDq^n|q(;qDJDPmA!5Rz2p>G z-!^~mn(n8Rg_mh%W}awHy2*|)u6XE0QLlWU*qP@dC*B=pN4CiL4pUBrd^B8reM23#Xk&t*6RtjBv;jp*Y{J*Y-JyM7bcdbjGaMAS2k@)Flnf2+yN56?`uk`f zs_7^k7UzisfF4gY`9uwnh`Gz)A(>9Um5*@TnIj-WX&DKce0HIMXis+%5(ta}C=>58 zBjc|zZ(#@Ulz*TgUD5-I93Ow95*xTc3yz}Q$4?(ck+CP#%_G|(DCAFJX~+Y~&K0hw zQ??KiZOKdQ01O$vP~$0WqRs~Hkt5d9N;kUpmqT$h0YgOjlLT9y{8)8T=VI5X($LmA zlvIWgZ_;>$7?l!K9PB^KV{&%vVi&|K6A81lBGx8jV*VcEA>*Y0SRu|VjiZn+p|IWagS`3j z^KHR3;X82}%*RZ3i5$L7S*ZHCFnzzrDy`cSSQMC@0!brmZQh(Md*QWaf*jT1=jDeN z>jO%PNz^w!#0Ai+Ov_P(&c6Qqqcr{PqYC;zOuZIcHCc%EG-Z0HoSsqcR2byhw}lG~ z;joB>a%Of4B3iR>e&O+xH+LCHFXUL`N8W#wp;NLYoYG=h>F%`)D)9yFv`;m;sfUWm z_Ui3Ye~4WFrMFinc{}PFaI7>&_yrkX2+#|{3l?_povLO44xH~~*^|t?+FdA$i9X>v z)8$e)%;VIE#mW}+Yk=OxC~0x6Nb(8hPk23Mc#OKG4%&G9^8X;|+vA!1-~aDz7{aJk z4s#Zp-j&139LDf=K2K4SL}gRSIaU}tF6TqE99G*5kq(GTQO!^@MwC-RgdB6o@%_C& zzuzBwJht2Ie(b(?-`DH9p4apFyy#KQRw?rrQi(@2mbZ1p#5be)zH>pj~ zhRXLo4KhIg2T<4#@4rv4G+S^GW=M~hPZ?PW-0JFewtRM)H@x$C$rILFC=IQ7>HCy5 z<-RoPh*T|JWXMPc1?3i|IiU)=brdF$ixEX+s?4(eO(WC_(`>`@_8ix!%F$omm<^~r zq8hid8!6=@t!Id638}`*tmX*Y*pd7l*;{?C z_8Zk9t&@DT*}_nUxLu_(#oY}Hb+hII^2%IT7cydw4u{hKahNfxlYdC706>qeGDLVa zutcYJ(+;?KH|U?xlYznh_RqjHm@E+B!bE|OOoF8T5LE{5=r@Wj=m<4A>j|JD%MXTl ztvDRWFvI{iCxul>nA)!f?Sr2Z9G&-2U#0$Sj@$@{iv|PEWJ2}jcfXV`{r@Cy zO?`rAIKHli2(yDb&zNLkK-?fWdE2+rZtFGYFH!mAv6-M?ietdQpTPZlY+}A_^v#z*LXvnIpr9*Z;djCL21`xy{H4Lc`~LwUUp6ceVEI?F z>J38EVd;OxD^ajUCg85AH#EiX!GXa1jdI$nq(P-b)j6fIM(*WH9^DZRi8BOW{@z!N z>7B)Yp~9^fM7;Xxjh`3nNc@8xm~gu8^OFiCt3=*NL%$VsG@)@% zwfIOz;xF`1%b607jZ^;tr}tUR<+3)s7zjDeSk1Lk9^2@031*Q2UctD>?%=7A!5@Jp z-Tv@Dz-)B$hTo3A!rdxKX-8FhY}CU_6TX{LL4*DZ}a9;oF%u^aS{@Unwdnku{uyS0dXZ@E%-d$bqJXB6QW;sORA zkd3cVca~|uKs#XeTy4{?7G*dEIzm-SoF!?diQ>@X8KdtO8PJrgbjx0v??f2`Rz)EX zy6u<~rq<(0P&En8jXpf4QRXktQ9|WD!wMq6M#9%Uz8B>bTww$(`x(+hT#b>OCDu$2 zRmN13jPj&S6m>@{OcSK!VToLMftlxRm8A|mr2`Oy<4Ib9G?_RXZNo`Iat6htd!hzI zRO)s&Kq#BK?}4;VTB?q9#Nf&G6Ab`PwAlumfhW6R2ULRrgmyOjkZZNOzUeY!iP>-v z4Z$&lV?;&3x)+<;9mGC#+EHBK0b-298^m1#?Yt@b&KijQxaG0=j|pu)tk~!Gn;lPfNZb9+Hvg*g z{!i!0XWO|4q*Wf%+P?hWY;h_b^LjdI|4YICOh&K*Y2@N8^hF;(qe7fBX}Fa&Q#r1x z9bL?Js+vrPDdpR>8RKS-S4N)iSF?EIr!;1l5pX@Y%q&=$FXK;hG``!D=g?pwnq8)!3RzOQ;>-FV!zzp)r7CWPA*7)Y8Xo; zpHJ~V8yK>p++e?o)d@4KxcZ6Ie_`Mwr?UX8Lk?Y1njIv>XJNK$?jvqumoEL;KVVT& zVZV7()a}r%rB&5`Y%SKuxe2bhjvohv-gZj4$q4rd*Y#f06@|$AO)u;6&P-f5le1-W zxp79z@uPocmZ&uJiq^~!P2WZ%BNY88{e8wq^KK4Xc@jg-kwq-C=lJ{73_~hc^h3=( z*N^#1_Mekt$z`6nA}jwO{S`&=-c4_fH?O%@-mji`K>i$7d>~;M?>0eSy5u!;F|z;e zO&t1`%I_G}C;NHh5n2^vi>?t?Ru|7`!j#M2_=nkf&e-Eh?(8+2*SDO^E)b4hv8Ew> z&*w|LR3p*>wdIi%sc`TCFjiRt?EFX*wdU0<*$BG7Q9bje2+cRB1{hvtL9cKEho~jl zs19f%FBq8SVI&Pw%1K5j4Yr^5$Ibq9e zm}a&xUm6ah`>HxZ7p9$(5Plfoh6{FMyGC6jKQtn-xKdA+;vO?8%!4<`qY648nKbL- z_i1ky2&*grQM0eg{EYGdNV8b?yd?888>VXN3H{2#%H%+bN-`wA7gaAfB+?C&o#7L3 zB-PVtfe>)jeXsHoo3GYGp#HiY{mz=MsynCcDJKj({wPU6wlX967qx+nf2~68u9Ry>#cm2Dq9K&{Qs~ zo1leZ3x9z$YT^~nuHY8PKen1}z%G{%ikWwY>TV}Xxz$_iU6AW_^wCFj1f zJ;z_QIU^7yhKBH^!L^g7g--;)ucum;FX#mvoK!n zjmzME>HA(b=r%C}o*%k6^6Ge$lFRw7-+f8Y!QC6Q>{IhT1AFS8YG5cczb~Zb&Q{l_ z?Cp4S@eLf7?CF2luWQ3(#K~pjOK8itsgfc@@F%Ai2R>hZqqhOd#CpW7I$-+g3nc~P ztaBizk|Bdh+$G&+i{~1e-eYN+(bH#Z@f1%j@|=q?r=ZKt5jZo)RmU06xlU1tyLxH< zWO7$Vlf!6D)IFJf*B|1ai-u-6Ja@MXsp+14Dc=NNW*}@@l}lUAzw8=lQn}K?ygW29 zyA`J^5oKy0@ycBpS%->mFBF zFJ$HEr(Q37GlM!`etZfOQnI74&3pEq-8mXR@#Xkm`kii?)sl^5Z&ex}Ebzc|# zL?Y%;s%_;?BTfJ!>uljISU{268UB&0aXYm$97LbRG>^MepQ55S?Iv7r4BxR^iA&mS ztv}(eoBhjv(uWt|d!jh-!sG8#wu^Iegb$aqcsj~YO}$-{gA>z|p8L%XyX-AA)8lDk zufm58^os<+i|&sUm$VIMR7PMgx=!j0KbDe#KirP&SM)kuidtqS+XdT55LVfbGQ=sJ zjyCFMo{*AkEQ@$P5gvTD^tn0_vvhs<=+pWMbBk9;R_4E*h0ZiIG!DntZ$57S-uFsX ze#*{cLG;7T&!i!rh~_V&Yh&Ao1=-EgP=)Wt$k8myQps>oq9Ysxt6R9hgfK&9X>^7T zxPHSz<{V}0pxHQ`8sLz%o!?SHbSo1#)&+63bA z;*nCT(3I=}_lV3b3^iPdE-`jKLnelAsw1RAl5HWHbj!(PLVK9Ks8XVN4j?|U$Zldt zEtdcUo-(<9z3Ua_4_Jh(FSDQs>z*XLCnWR1QXZ5lwQJI;ak3{pZ@}Ykd?dKMwz8L- zkPn`tVO4B3NLLM9r!Nn6g~daGPxcd&4uncKBj_zz24INb1PUN^eriw@Zahg4!*O-y zx3Oh9$j^`8dJBmG^ zPxr?rNgFM&57;{}L|3LQn=ueRrX2$i<(x9k2;gDk07~UZYa3m&S>>UIgbYT+*4g-yt$KCP|*;YP;dfu28NpAaUy*c6b-q&t}rJ z01E`EvO4r?QVARapw=8%$B%`A2n z2FgzoAo#>dmzkl07)@j$ctNo!Swm3hI$}$Su#dBsXNYCj08iZ zk*}_D^ByRLwHjWhyNk2UB3Uhy_OJ#KxorCcMSX!EnIRjIhWWtJ$Sx}INNsQ>>&r<0 ziQ<*)?>1MRel*@${jGR4Q;M7YeBf5;cS{aT;K*c8 z=?BxV8HE<#1A|rf>h8$%nWUHx$MDw9HSegrFiCsy*_w-TG|v`xK)T9;>aFI?E3Z1g z$rdE`RsTM}VUrUQzcN_4yt_N5%60FNeT{2*^dC#)Hm3tGRMtE;C-n_oZsNFl>5hdr z{%xF~6I$%$XFTk2@Dy5Mxn_GprM}#MfHZdaYFDCK?h?yvy^DZN!^xKvRgdUNV~gAJ z#q|&C206 zcIG#q>{co0O!w&)yM7D+;KID391ak~C|~sJx8?dodBNoc#@h|jfLl+BB4>-aqnR%= zaqibcd!2&F=BtWP4WIuU(W)ioDW6DeU5{dk7My=rUqhSK%X(t<^o&5Qdx^_{^zN3skQMS6wH6bXRyq2&Zbv}9+HnYszZQ|ol{rFYI zx#-__q7!EkKDh@1JPTi^>EGLzW})bRq|artx-R_9o@0&c$BNl%9$$$|EQk$KGN7(F zRh^?q#)^K_pi{cE>uwHSanZ14zSi3<`2M%;{g-bV-uG{XEmn;uyr-HR{8qtF@NhA- zc~$ohtbDiSz_a0a&fylp$VPvy`iV2vot{-AZifXi*^|@JcVVcQ8>Mmt2dYTSqp=mfA13);s zyv>2eS2NZ-00Ur&k@kJ80}t0OY*M`eU}X`G2ILrKu{A+r8OfX`w8xb;En$H=0Z0~q zLQ>FLW;ZsCE|)+dDgMG?u-biCzfN4}7D8N25_AcOVDZ*gZ3zAB3o$lMq)vfKs#qEmLURDO@${9 zva6Twuf~f4N;3oBbU^Xp{W9dwdQm za45wS(8vJb&^%!>0T{_B4)*-(4rZ!B!G4zGG~dx=XR*Yz>L0e2oSk}lh__?_0eWZT zP`8l{&**>^9<3%Sq7u=46Qrm6vXOsM=wx04pbjWniDHn~&*w|?*zzLLJ|lGvxB2N673xQb%M(%4;Wgg-RgNXvYRvvav`iX)V`R zMgFW}sGl*{hSWcERIY6&2M;3dJ!K&7t?mx?rKX*FrwQ`YTs5VE4#KF8cFtl9lj8$e zcMWByUlXqI4-Vx|&pC_5i5?t?Vk#3DGGySsav6b-L-RGyrinAeG8?(t2F6?D57`9) zIiq0V;EjrA>kQ>YP0&ojUGx-9Hac9%u4Kb*cbJU`#obP`0b|U9%1}D93E-W$vBVIY zm%v^xkTn)S^VWo+GN$f;9!?{#B!;i1lJh2;3t%(sG_rRTvn}LX7(Z>p=m84Np=2IF z1U)=`Wa7xc^|1|ND4rZULIa%7c7E^6!v<+2GH`HY&XrZr(~2Of?qApLu!O8PW;-0Q z7w^%~XA|Xse-j7-#X~RhaJK zONKt*lc{T)roB~ii%U=THq(zs?M2s}=^n{eaJ%U~JSLYB7p%P*{5Dtr9@l*_aLui& z#>c|ZO8pG|cDiGJ;xymZmL#_$MfSs_i&=LCj%y3iphH+;d@%IKZjw2)0C~46pQICS zUNn`RyHxHlb5!D=kC`39I+c~KQ?*@4M+i_jA)@Md@!qPpoNlY0t#Y(f#Mg<#F_1n` zl*4dW4A`x5p;a9w@Fo0Y%2Ljfd{ zUb+ci+a!tctC}AV1n;@WSnGOJ>^!z@_1vYXCf-7Lkl1IqDbc!R@v-}9Oi23?gg&`{ zi^=;*xIMO@VQS!W(#bG-!iOma48_^1*d!4$vg=xsZDiFldU-J&NuSktQiHUstfINF9^}b9; zyJ1~8Zk;9;iw>{sd45^jXz#_JcVLNsk8N-kzvRmz0_RTbm`-obz1}K;?9A-#p~mOb zX+_WiWNu9p#+F+cQZivQcmp6mnuf6@uxCJI0SjS5MlVl-ky7kcNWSjsSloCYu$LO%NB~b1rQO#(rB?e3-2UL(me5VmZ!}>C$ad;C&EAiD8wpw7y z`Lu6aXoyKV1^!Mfv85g3rh^2MlZ&c<|JjaVHM^O4){eeI0<8|m3mcG`Yn~O|l@)}7 zA9h%ft~1)>*$7dp5^_MMb$ZM~^(Hg3iw&4bx*Id!H5>rFIv8QLF6hyx#tg9np?^{L zrUwl;GxA`FwO>$UbO|t;XT!DgF4v$>`w(Eu4C1h)uO|dDCX~gO#WLTi5h3FEGS*SX zdHM&sza3v4$I0YsOM~GRgZVm=5|AOa-yzWrMD7r5Jy}}FcgNU9Bxv;lk(D>=Dzg_$ z!mTpIvMeM?jq6>vn^ss@0LE8G)^WkCGOe%-G3m028HDf+{x{@H`+`~KuXO)F* zWM5u%3oSI3f_EQFyHy+fdffEa03x@^b91Uyfd#Wy^C%+QnJ@W+g~=}LEj-2+k8w5Z zr2!<>8}JfQT!yF-YNHDR40njdkw1WrWcV<9k+G=BX##J;smK_aj9US#kV#8<^Y?kE zl#IAiO;i9?k+Q&7_3=n7_ECcWFKYKrJ9N(*vyA~5*9Zp2ISCN+MaiHo(9?uvP)KQl zpy*H2{WxM7#m!XNc@Rq;2y2hwQ0Qn#gJGgAeqA_9*Y8CF5Z*E)v8#t>n&JsD=Bqcy zh!9sAnU}A1z+7VlKV2;>9g5lTdA^zzah{_?w<6#~Jl)iiYyh;s15D)0;|p@36?2E& ze)x6!unRxNpZH8nOZ`eOQqr!?nTsaIPs0}J-q1Z=iNrHGwFuo0(q21-16Gpnm2V9x ze2~1VH?%XX=CyspTDcH)PD8GM)~S;74QY@;LNA)0>hY<*HxW7!Thr|v@!MPQ-3mWmg$4(Rd zJl_6c?P;$|e8*QVAKwfG?`*Mnt=d*C{tiD=^VS&*(pCf8$82h*qxW4pQ}pxQS62%Y z(W3Og&o@QSw4V=kn<8s1h-HSnwh_vj+OpC+KuYnS<=4!OI*nS-!Tty^ebjm>Z}jqy zqe-r3jopu<=RioPcuIHzaXAMueN=m)lQ(-YN7ehxptHG2+w=t;_$hWG>g^zLw_n- zH=S5b8NIOoUKZmUiiKGHg?3n(wuN@zSkwtB=xkOI$PGch};NCaoL*NT_8I#TO;yUK9H3JB%B9e_HPs9r`|a z+7nFc9(TmVk4GOhS|O{a`aaYNpH%~{USWqCApAh9t65xS*pL2XjM&P7@(ST@k9q(n zQl^>QU)21(#@@9!{Mm=dJakKCgF9M5f#=yZZPOTJc2+o=hL|{-I`C~!MwU)c!>=|QjL`nFkwa!#oZMF!w%#4fSLj_ zNV&|gizYujo-b~%N%KhNQOF=lvfcsBwl|PaCL7vO06$aW=(IzJyTl-f2f_O3@SbD= z7Qw*+QoH!Lw2xh`VLZp^fiCF&H#>|M3UV|m2;w)*Qm!%Aj$II%b1{O8@sFO^Y*!`> zB7rH7o@Bx_9S|Q+50+>>Fb5`2fUPK+Xo(w+;$jOr|GGoRGYSG>AWzp3e*?}|qTW(2 z1p_iNAYZy^+Lbrz2uFgA1=&S%NpZT5j7cO52A{SRTS>32Hc`$yT4{ z0wOSbyNB5Nk(7~qX^m_+c63IVjZ+=97g4*y8Wqba_POjaLy#aaI=lMvAw1Wm{1wKS ziZraK8pr`z{&rn#HARORhwSbN`jr}WxS2bYD7PjYEkZb2fmwMm#kz}qK(+0r=zebB zT^$R}WG_nruEe+G@2NPOBYoEU-h_m^4yb;h0XeW{GAn|ANV8I1$84ztiYn;LbV~l} z8LMo`S3^D_p>}Z(&8JMzEgPo^Kx0!A17S%s{vBVvYq0~;tH76sr;%O5nlS)acv*gm z9LXq1tFD{CH8P|E`r zSY(R1v2}iM#S(cwfUiuq(3V0w9p+*TrXTeq$!SYx$3UCl3^$PuAS|t@TLoWcSOD6V zOoKv}o$xa3p4LgbeX*CmHvF4b?)o&-^zyF-D&})a8t92vzaen>3p@wC0e2JHg+r!ZlI34XoIz^@IU}m{> zl#cXoD z<|mIJI)wh8ZWXg_gU^p0{r7yv?b8p9$C>6e`nz{Tl~8ZAe_m0(VBq}+HOlsRoip=Q z#>IW7Nc*wG|A5Gj#%zx2rv?#9n8$w96-P3)b`19Qaq8Y6{SBXe};0f(KzUcc?m zhJJ5*ac*HY<@)tPH<0uWsX`cSYjIy^&Fk7* zbD_)?Zd7Q(B#VV;k@C(JyQo68#Ep&LO`HrGIb2}YPYz{Lp0;l1ioDx(`Ba!YB@LqCW42Q9w&ziTFr7Ay5GTtA%O+9$$v_YJPU86%Ec$Wpc=DyrH@7rDHF#Q z#sdc+F58{;_;bOf<~hTaJ$DlWXL^;#u#Xl&@xTFTZ^^4&xzhU+gJuwFkTm-_A}rJW z(N2B-aeLpy8`@OquZ{d8cKu4Ijbp5*_iwMc9DA2IGhj;@4Fi44&gpSd<}rUQQX#H* zOc-zXzf>KV88JTQ09J+)+1pntD%9337Z%M+D_nIY;x^em^wuuX^s;gTGlBAA`su zS+<4_Y5K42Kc;=j*^?cfxSI6DzAObdcA~A#G{Yu1_|^1~le~Cmf6nRZi;|W55pO;w zwl4AAqDDx5ANzfjT98j9$gn*YGx`%MACNCiv~nWt+itcV?3HUWIAS1fWx0M#VkYQD zzR8gh%Twsy*-t(+WTq+OZ>K+(2nV}ANP;b-F{K3%}LnT#>u&^`zXlt7y*dS_4!75Hg`1O zgi3W34jbmEKR^@H*6+y~t#WkU9C}}1TmtnE$6QSj%DijKQ$Q6c0(u7G>~^FO0Bb(>KAyFAhH8z||(;(U1@FlP=9M z0z9c@%5;TomPV#Fip9z^ma#11*}zPKL_aM$q7|7x3bL-uP-$og+%>_`?;9L>jhV?k zBu3r!vQl9ZY{Qt*d_f{j1l=PgYCKzQg$;va8*k3vs0pV?CFpx2Wsz5pDgAiWOHw;W zotXB4f$PT~LbDq-dW0&08$|*S!%3R`Y#c@z~cMmU~&=ji`0Zk0*TCQV_?8_*CYb{AJ9DAN)NsKneQ9!h3u5u*JMN1Z}2L!81iVVn9MTrSGTg~4Eqm~7_1Bey3B@ssQ6wJG? zN3=4;Ml!nYtg!GDcbI(Gu>SU6@7xFU4ss`ezfwSxB^&4G2+4q&Jlgo*a`MQ`z3~m4!AO= zb1LC4-6+;6Ma|T`93ef1jepjYgrQP{=rRe8;#^>%btFR^*epZfElfO9{1u%=;n@Uf z^LOoeWsJp`NqhJiy1xQnTaRoH61p2#Sdjh(owe~Cm6#@$83eR%l^tGXkI*S8bhsbb z+ZUgpNi^da3ten&hZ1O3e9nzH7mQAc3;a7BptzZlJocUQnqqu;e9F;2?^Ay4Gr6S7 z?qix=4ca8waUa%{&eMz}W3;O{GIj1@8x+2lrDj` zuXX{t&$x%&Jcx~}sXLCPdkcTOO4;NRqPC~6RJzCQZ+Ww$O4^jTr^{mYpdJUm`?cz% zU#+yZPvAnPux?I~TyoMQH2I$f*Zt3wjmux%cs|hQpa9$?8Y5|DQ*D>4PcWm-t(~0G z_1f+FP4SawQD>c0cs;0)pFY-81{LF4@4w+WuCNH*`H>ifd#AX*qI zksxg*V@Ob#UhhtHKwg@miP>5zQ#`4g<%F9BnyrkpHZExEWY61z;M@ae&;M`(1yNAq z?Z2b+FL#}CpDh-*RW&^{l*=Tb=C6a3by|aGL*-JVo|1O(+T4ElxRYpgYlKZS?CxF1 z`vP%7r8rh6zzBA#!o=~AY48$-a?sqvra5drCdOa+ekBfj*xi8Y?R>A4!?xG3?1%)t z_+{|>kY^JUhu%zk=lceGwj_@YSS7r|?VeKH`ueOhWS@xG{%7WuyhVO2HnskaR)>>j zlO_i%8wT=54Y$zpYLKJq1UzY2(mB%-B!|?u@I4AY7>{yxU#&&_bT<=O>IXG_dUnoU zX}N6k$N!XS9nU&E(B7Df8ivuTR;<6$GWWzVvv3ppQTaoR3?;axW&;qyxyd@Q=Ww@L zX7t`@ch^R7*cJRA9`;lW(T0vR>XhxoRveQ#b``grz@G<^8W5d{NPBj;M`(lOV8Q~McYYmu!4xK~|85=`f zJlY5_WRmV{#*7yd#&ckQ-SreEG?E6ERBooo#+8L762$c#U9@9HkwGD%dVABiYhdZk zR2*Lc%)QSpGYXbV3Ni75k$=27|B!SBy!5K!H6i%sB*dqViRJ#Bq2u5Hg;&M0J-y z(e)yDjsQ6R3MBMd;UgRYENfQ}m7`38)+}!S)NeibuDyC!h|DlAO)rd3eEsu`%JWJ; z@HmWs9E!&zNKOlL7FB-TnLWu@O840T4k(CGP$pLxk7R2X^03tNh6GJD;+P`XV-i)_ zBD;xYz`8q~fd!Yz6k(RQJYT0lO^FZ3j!0`8m%t*5^c^W-4($<^pnRII?MnXJQj(eO zL(u6EsH8b1&qm!+8ySRww)*1_% z6dH$a`He9Rr3n338StQvfNZl3Vj$gw;tnm4OwJ8gNN^J)|PQ`eM znPx(S81|$MyjLFi<%Fi$Irg_7Du5J#LL zpgh(*8b_!wu1*NL)x29Sdx)ykZ#)XBDrn-v?%{SQML-6$pG!`*6v=dGA3_5%@CwA6+ftfJ;5PW>a|lMx{?XvV4<*1MGJz(R~Rtlt!_m>JxgRVO$0L*(M=3O zMtomlEP?cdf~)HuT~EkxjYH?MZ!e?5f*;Vy7ETctXm1szLFbP)Iw#~?k~p#L#75I2&{RT$Myiv1Oz zlYi^u=M?#!;&Xod;hE6jb;3@Zk?fDt-D%BlP8;)f*Z)X8vvkVGc=1}v+F6f5w>7>L z>*{UnXbZ2>QmWN#zgCEXyqK5YaCc+(y>yF()H~I0Y3ql#)r)kW`L|V==!tlr8&Nhp zO@6Mf;BR1F(=;hG%IYv)dlbMi&(&1je}m|{U*pOUH}zCQb|I5dQFgXflMQGdL5P7p zm^qh2z1sQ5-5u29V@k5{xYE_LaTxZz{RmYEQlOu?U*5I{j-Jqa=Yq95vD0F zc+=>xdE_O`e|wq%x%jy)O<_aHy7SJj#H zW^^h%%RF`6$1(lK<4$rL?46{z0ZT70hD@#xwL#l>6Sa0wIJs?pYMeZUi?dOcLBBz{giw$u(|@@Maz( zt~DwTHvS-X)?Jg1M}=vKGKL5W6tipNZ4Uk5;sSs2rk%w??O<$eysni=hT&hKsKP7; z_#9M1wkn{|G7jO8uOoV>n#+x>-56&X^!_f8U2P`y$8`$f7(E0s%#NshFVs^?>3m7c zP;bX!FD`S{G|g1s=PB@z^VdfiZ1I?xWrq05=GSR^@1BxoMBoxjSHEQwlPK#~2Tlki zUS#Vc$v}C!4e_u*S17pc!=Hrh8l65> z)O+~m4iK^+?jFV7Qn|m(5Q}@{wl-oh_YNe&7Wt+Rl>P^R7{GGb56dP7*pttYGHkQ> zNdu3Vu$3xCemC*Iw?Uh_|1;F6hbI%{?vKN^i0OY7!0{4pCcgg7;1>Y(>5{Q4#w@i! z9N5kf`Ezc2B;mW=CWbw(Gpn}gatMDju2gFRZ0d*=KhXd^1%!JFp8f|MTT@*qLp
    z1$w=Xb+3XL@Wb<`wgd@so9Gi9)dZq%Uufxa8r2IYe$x7~HL` zq#Vmw9vi1>>_4=*axo76*HiI(%-UdnLSzQ~mu}Mp$I>Y=Wwa{T-*z|Qmzaqp*>`2L z-0gifl6poYdUMk7Pec z!{Ih~*DkJMK@@U0j0i8=H1FB&I@=d1xUc?6+wIuWrt}rH_1@%PCfSod)qAbA_Fwxn z)xi7dH@T}K^Kn_*^P8&H#81wd-6p%i9=>7E@OE1-YU^vslpCP9^#1FUlic;wE2(K? zr-!Q4gy&Gwzo+ksCJGwPn=y7}=~n*C{cIq2&-a){9VLF zn4YY@I-@u>WU-ub|8z854HTV@J&91qhm#wEbuzRnvd*1yRXCX>jV{u|MXi6)P|&&T zX^EnA+x~zrq!1t6zO_&_aa1HJClEBwFu64&7qk^1R4S#c-Q@zuM^RFA>%?|xLddXS zy-AoolL3WflA!H&6f4t-bVsURQ}Oa$r!dlI(a8Mwz=XGQ&ClJn=IQp)- z^4Z77#f~0jC$E4fwF)cxhQ`Vm# z@c4Va=fUxc)|OAd1IW4O*1Td*F$$0 zh0)u$ztsr7UvA6W2<}yl*|wz~N{Q42$?LI)3%6ceYCk^FEqQw8G2vaz#H78nlnj+l zjBTnA%sjSkKe-56wbhCYzx?Se9bO(YN%$9*e8QqXdTj&DxGi2Dc$NA+SM6|8=~OpM zR8u7Lglhl2x^1&9a55;zuXgxGuz#=-SP#-#wg+l;w2VM=lApDR@9Dwl@-H>V}V-XO9zgRHlrQW;C z?B4_vi@+{d|`dKCzal-+f!?&aEU$w=&>)-hw zAkep$?o8aqUQcfa7p>a!g7q5YE$_ltkGf!yS@0U|sSn$|b=$)%lNz2*FnISVJph$0 zgK29OhULC0w0F7c-LtN^({1@m^%jogz-caM7D66Kc(F!IAo~{23Sp6Ts%hU18raQ!L0dyge<`3Ox|0Awalf1)1Jd@{(@b5 z7iK#gXLwv}#JUHx8&S*MX!~9WT)wQrMBe;&_QH4a9iCz$kp8cg67ZVU~{5L z4RArB<3B)lb5iPm?kPR)JGQ^b`z{3o-G8!i1Bg+(zFn%O*0em-zGUM4ZBs~8pFYd8@Txd1q@=Ta;tITv4=p8k@-!|c! z4^SJDvCP^aZj6){uX?3qesveEs%EPOTMp137nvOTX&dn^K^LeF@$Bwgxz1B4uU}Ek zRRCXV2b5T=j6rpkWpDEji%jrUB3fKi6;IkAehH7AS#vjy+yre;RD(}n>s-mjrxHw7 zHp}dOtP!D?t1DH>@MoosTBATQJJK9A|7EB?au4qP$+E4n&+l~8r{YSXs)$K%$}H<% zho2@7DRrr8Inb)p9G5K3)|$m!I({L*?3v zl;L8x82{G%cJ5b~z?Zn)F2C0ooU`v;Aj(K~pZ^*pYW$?|cSB;SOP)n^zDnaWh^quG z-jtXK78-|;zde@Osy9gxxR0+CafM|jtb-{3+QLwTin5}}I8q4^S0;8jE>)cF~uFI4R>610YMVl20FC^;++05O77_qUS|X&%Z5a z{p~7`wLWt%UpJbt-0>^HB>#zlc&Wn*CsgXts@sIa|86?t1;i1J($f>yTwThJ%6rxqrL z+l`x(?9xF{@c|wPycLlT>KQe_LAzDE35Vhpy9wI}TN31IT&KM_XzDX*2+mV8HQol> z)CrB?4zECi1?WVl-Go!-R_9t*1SlLh7=b?XO=u=g48q_{mvZjZVmW^CucE8=Q$Kq>uE z*Au1eN|-YjOU5%)eSjF9?)al;*VEhX z(|zd&Vb6!&vDN>#=|0vSaQL6P)p&b#(&2x9gS5;!Mr=)y`3j(;#zFBpJM)r^Y^Q9S zMvGl`BV;jhI0=|CUto6GJzTqV$m%WfR06}!h*z|K@ZlrixLeah!GK*}}{ z{^V=5sEjc10vSeQjIMgFjAWC+4@Ot8A)vCb&t*ULK1;h86l3g|v1ufQpatLoE@~7u zx(t>X(xdx`9N}Fm^?ZS*z?vZcOZVU5s7J&212I3>*1d`fAF@Yp7}*+5zO?8mYmQN< z++qBA=PeQ8MbZ>j0Q4C?=ErH>?G0x5ZW|x|wdY92x0804FWyDj>y=v+*RMYDwtcr# zG{P(QxC^3Ce$tWQPjp53_==2&$OCUaKtq)Q2VW03`50=w-3#*$dOo`^=CHQ55ZB~eVw?4~^Wr17R9gqK12)Ca z;MV{aIxU36QDl(x z`F|6lbf}LZjLVH}--MY0S(Y$<#kEj@{mPzYM@|4YjvMLl(@Fe|t$ zFfJ$HfW^NfRI*s}2{7loR`9|#Z2SjctsK{>9L30ZzVru%OvnLNYBHWF-|TqErfS)( z;>$~bSKS1N8+g#kNnEX5&~3l`r^`+Ye(B(coA%II`&ge=40NXBnQ{5(hJS}5oG16* zJ9|~6z)w0ytp#a3w|92gWedRzRIVto$JdSl{?k!oMf3>OLDncNy}s=9A} zX^#J~TD*b>makYTwUsHpxA1Jw3TKWB4o$)Q@I_)-rvl?{QEROi0Ph+6!JUU`*>@LC zto53Gc=?UJBVdx(CvX>ic#)j`NdGR|4I|Dub$rEmS=Hr?=?|6shc{0hTiHF2%lAhW z(y(WEU)q$yCWrg8CYOLN=e~|djG*tCzet&&NaXaeY%L!=e;h@Lemjn`&h52$jB~Wk z6HkP1i9O{Dt9pdxw60a`fy=2ax?gB3P9rRYZ{fRrt}nGZM%3CRh|Du%Wq-8OwZ>?= zNcMKGIXj&Uij0zUeE3~_>2W)h^%T*g-x)JubU=Ie0KbUP;4HT->=UKZqkb-D z0avhDBq+Z`$%={3-uA-<)iPJm;CFlF0DzM4uSE*W*-Qb{rv?NE zIi2}DaV&8uFx?ej;?n3f2Z-ZB4}MCI38^w_(5~gpyjwJPu1MyH2F81@Nif8Z{O;>dbox8qF_@v~zDuRo+$@hw9nCB%&jh3%H!l161(rfWV}k`tB} zSNdr)$=-~d8GcDLx@rAD&+^3^`yIsT4JjI#sp+2g9hcq9mik^L4>bgrbuL!M4Iuhm zL`vg?FOMRXcI-HH1`qliTy8z&kCsCzwolI4W!z1PASV9WQmiT<|J-BCx`h#1Y85HtqQ@pp%|KVs)u{y~yWb z_@f_pQ+3^CkWL}dWA`=o28KU1|3THgh5JJC`{S$@qJm8@Nts ze%Bttd)7p^@tps=waA^?R@3UMh?;t0B(i;ik#)jt~LB|MBGkO_4_P3JXk=EMZc@l2!yW`N)oRj};>>6y`ukrL3pqn@|ls-BKO4oXKAo3ODix$B@Mxh+0T8PiX%MDe^vWya$fX<9XPyFa1BqI3lHUC7&1h z7y2?>!&xy6TclK~DXeNvfZGAW*G@v1uzY33G&EP5@Ti5i37%kv26thi!HU;=A!gs)Vo8^vKi%OgbV=fMlJGeg_PedpJLeQK1@NLmPK z`^NJz`3s5G3tPUeVT&5yf*aP!tQb*i+xV>T4uO4r^q-kI5I`R892}iYnyWAueMEob z8V8Mo!Sx8p|MvtSq6eph#Jm0=*#R=X@K0a|D)AuYp%wH`qO25f#2;=P{L}^x#BA+kQsuUGT1GipT#D|P`2n&CW~g5e>yUzL z0z1(Mwbd$*fZTiq>H|A7l+F^qf@JJFJk6(`N}ujHfeN{3n$X^CaB{<(YrMIbEjQav`I2NqH#8Vk-AyN+! z+r2wV`Ig`!s#fEpYnaOPeWHf2FU6vIs$~UP^bWNG2IRkL-i^LY9i(}2$m zJk%)!Z|-YUbZtqIf_!dVjAfkDoOOyp~@JX26e` zpZ^vE`GvZ}w8FdE*+LyK(H;K(qWIqgrjoP6#eoas9)TNN`+7LZUKz}7>2c|2(h6X& zaBa^5lRIMA0mU5jscYJ#(o_!ixFaI4ZJtiA(R;K>S3xXq$IX>04|$_-^R))&aysIG z#D!O_aoATKaTs`(DpB;K1#CiF|FJjzyqweWtw_dIy%>HI9I0JCoMi2_)+?~66c)*Z z+PWK6^Rv*Ado}ns(IM^!ch;L?UqKccPieR&Fb(gS7h=>ftEC}CPH`*#zZXo259USs zizM)O&ND*v0^UK=VhTYg!n8avQ=lexU11QN9W<#f2b0)pxci9yV&KqQYOUuMi(OwG zC1C!52Qqi3ySl`&KA>yic(mA5!sKZ2q;7ME4PD%A(}ci5u{`GR=T>Dv7`hWe| zo#3nxdOWNoD*8;t$t&6}Mh8i*Q^#*7y(AK;1Jd&M;zvw8&dC_Q(@IM=9E@_Sa8FTdD;fh<|kXd_D$gMqoB z>VcS!N51^xx02nt#dYEdfhmurqbNuGJJ0ZPs}Kx zQ2q_@2)=L%zw@6tJi<(oz9btv8s@4-D1hbZ`J_s>k)cO9TCo^tQG)>Jp(kE2dJRH7 z2$v2;l+f5>H&Ww~s5%UUT+cd=m4LJnbz70c^g|%%7LN_uQ#b39Ib~PRw&-uBI~tOL zY#&JIcc=4|7r8J%5z$Op4kIEiI$2`&64jg|csTi-CTKex5SU<^#C*XlH8u_^NicQTyVb?M8G&@&s%X5ix74&ohv$uN#TA+@?JHXR~FR6oCKo@PEo+w*S@C|!DwsF_ep1TUh@E(v)T(Auda zwnqI4v|x=-ci;F(>BUNq!h$%}n8)7amz7RcE@C&okh~msrkpD63yh#kI&W&^=k82l zm-p4Y;Iov);Y+Kfm) zNU)To$Yif(3dq|~*=7>j7@3Sen*0PQVTp)Y!`-Ygm%>9?2}|nRc*^taUFIX{WRuG! zOB{GN?I{9SskyM;q81#A`Dz43p*BIAa zCy;D<>OLuYb#rp{Q?9cw?Wsq-@)HdT?Dv+Em(49 zA5C?~FwGblrsxCs^np+dw1lt++c#s@Zue$@GUX%p$G^vZ= zleq=_TKH0+T(Qn{H=~1S{?&1_;pNKdsyHS!qUvCJ(7~74a6{3%rvlO!_xu|bQ_4f2 zEl=zzScaWK?uy2AHSY<1U;Ac5yL-U2r9Vsu@1n!7dVsspCUp3Dfj@WC}ctf?h*9e2q$9D;Z4J8(%z3&T+6XC?4R{h`i@hKC=0nv(dG`pUyb z>04EWW^n_6CM77hk&orQ%IDK1lh44bw*-QgM#=rbqn5oFKn?mVug@m^<4xoS94*!< zo$O)(uSDI!V&g!+jJP(YrFy4M3?zpc3A46orob>wYBBtFcqmyy{YR@tO%AfAB?t@| zfC77ZO6Ujq>_^s`FLIE8j4C-u|+CdsziA?r=?oIDg)?6WVdg#*v75L^ZaoIxeRFjzU0@|{R#jAobRp{CB3pN= zm(UwNQn(Gm+*)T^#2a80+k3T0#Tj6)(C}A+l|Nz{Z>%0cUh2@pef_CakkzV3wVTUYIEh zFi1>c1bK%)c|~1BV|aYm|_4$6jWjM=^{1uRLR$)ht8hscs+TqwN?kA zo)-C=T={Cw=+(U&ev^`RQKlb~1G(AhyGGN8!pwC%;d2YpT(HNPjUEPP*e#mp`|`sxYr5Rd*sP43tyxB=<;27uTs1-|F+BRc7i;@9Vk zbeT&N9`%39fJ0giK=RpgA1$McBy@690X1?L_0@&@sAND<`HvZs#HcPHt;SxM0-PYK zW3E;zt@t7%MAm0;V#j_)b%wR%XV_oJHhrn%FSM@v0WGr6=P%T$FRBY0@I&vi!^$Mp zkI^1f%i=m|f znP=0N$EeLuGuFR>>j8u1dPT100ucQrwW#KpTnql+0O6JRd$yq_|=Tjpaum5`krCD!Xjovir*7}Seh)V+} zJI?msJ5N3W23roC?BbAq!Kqu%cHz&KfA8mL1>{SUQJY`DNid3+e!KSNYxfYQ_y2{I zh_llr2{~uOM8n_#-re{rd3d}x*WpmA?7z_mqOfr#m)|D$i2elsdrymCd(GST(yr{^ z>(ug6OK8>5G8hKeynoTWE2aN2c+?k1S1AO=d0A>p_2c+7(cZTk4$0@nbV|u}g;~66 zIq?^gkzc*=@5Gju&8&FMAoOp+8S1Z!*>V$_ark242AF_pyT{E zAf(kDcf1Kdcf9=dZ&8${>W0~AWcJe@e96D6+O|3ik|{6#4Jmuos+%~Z_kZ&|G^gI= zx0Uq*TmJQ`b@u~N`FqjYziZhNHdMF$89hk=QX{jjZ*o~DP+hRk`By!s@r;)I<&$8E z;8v}B+AJQSt^W5=1j($TLtvad<29FP-~#OBgVg5R;0ZUsMutFW~F>0ObJkSoS zeTqD%^}C+?Q2|*O3;OKeHpN7~Dzk+}^WJ>lzp>f$*?!UcCj?>1w7MY>s&zUPq_=(+3@D$e|Wb1U_Ne?1J03l>52rQ&+F5AkPAmQW^ zCagfdXe<$<*w4HaYR?A46=*CSx&X-QXuF&v*%x>?n=VhAP$!SQT0^1qcI;s z`X|`fK}^6LP4+=B3U8JntDszGpo#1#>44n2r?ueJ6Vx?+`PeP7Ggr+gy1J6fHfU2g zEZs}5-*ActocYc*TQR&=v7Fbdlqqry|D@UgXosAz{^QJGCMU2tDke@g#GD)s;EOTH zWI<$4hejS!*7HCI9j`6{DYIb~`omU{8|YrXbjTs*c$F#!zPTw99Wc|n0#EEvZdsKX z6;%%_EIy#m>tBgP*E<1eZool0t)E?JBcV+gCwl1D&FX=BF3BY;D-*~}^#OGb{fhi~tDY;(K5)vpbJKOF~6xrneIgvbsZ{-`! z{>+}88OCVO(|S)KK!o8Hdg@!ofzBgOP2~>w!IN?ox^o6L><0yS${BbwsKrKx$P==~ z{WSEumfN@Jz(?E4;F`WFl`uJ0w2Buhi6>zWC1sJ@5*_riJbkF z%TI15IlRhPFa8nVQio%I4SiE$?bm`YRBC}nI>ihVXavuLb*=czrZF8=YPp%cIk!}L z8`b5s5j+#N>)SDoFKj?nY#_uqRrSQOf3DQW7?!;pEOea^nTxu`GwVvBON3q;#$AfZ z!;ZwbgaGCwRP0cWdtTMtOV5Ll31Be~`(@oTLAC;0b9*#<7cTL@7|VQ~Hx7!gk+Lyk zsWDEq+O(pIAaU(jXSMbHcdC{*l5Vs-V4v}UKj8Hq==^XdCjDJnTD>k+)mG|_dfI*p zqKpi{@_Oqhu{qk;Qth6qXtP2)k#ivm)q8GfNNEB_&-idPA+H6%fen(4kQ^RXdBS#? zr6^wyIFOS_o{)ll7v1WNa9g5<1`Z}9rOdCt_hVn=rBQC`xt7Hgx#c8J>YWg@%-*eL zSz$h{zZ6sg9)R$?6uthp1t3{2~8X*nb+rhWIa69XFy_z| zVpQD;BbgRU>JO91WS1o3rGbv#o5(vDsEwyi0hQ@c>+YoPoBxPYlK}6(+)fA?K9pnu z0mmFo_O2ikq1@jjPlP&U;*culSX1?4`m^sJOV@ioWMAJ?G;{xnGq+?|?XWd68C8YC zXy($r_!v+N1e$BS9~hWfBHhc0F1}U8Oz30*z226Q{_ak*sXz|CQO&78(G=4xA*RrL zBdbo`4jgHZD~S_e6jOlgT=jv+fqU#Jiv9gUHRs<}_E;~Oi+<`DHF@R*-joGh(RrbO z5rXkizYH&f_a_04#5L?XUVRf1V#?paQhwQko|_9g@l{pzx<|vmX}lRYAGEc*ytnYv z4w7f+_8SQE?wdIObgxfW46H2)s&WvLS(WRen0OQE)NC3kYdeLwktaRZ~v$=2MG z(ky|5oQ23+tr#`O1JDAuN#DMZae%L!^UDUqtzdWZ#HW7ky4?lvyCR>WsOj}{6aoTDKYvZ&wFMepwXg`~vJ_Fj-|SqlZ3 z;nHfhBLZoL{!iX+1-;@+Si0vlAQicBVG(Ub6IJ&{aw^&K_$W!Bsu%QC!$)$jC#iLU4?Ds zp9-n3;HR=gHwl2G{WIYEo(obE zjN1HPn}KcoLzbYVu-JAcw#HfJX@PSH<9*Vk)xAF&XB%4T0w)YEfBFTG!MB#t3uyr; zAY`ADA9emK-T%{>5fQQm(EMf?sD%=f6=5y74Tkn-vL=>XtRWOeY)=dB>9$;A)7D-R z589oFSL2I0IFU&w>~z|FX-FC%Q&(L#&)u1bf$^+YF)B^FrUPYU^SYo*s1%;gal2hZ zrh;3VJu_^H35MP$vn`~6=)3k=N6mLUu(upbJ5ov1ylxtH+(YW4T@3ow`;1-lGS2aH zJMNiXO8N`km6lAmRK0LLRpvmb@GA9H?v65&4TZ$t3qbF=Lbmjd&D%Bs5Kkij^w6ZE z{&RYTS(XNQ246)3#;4!?wI{=;ViwxP#9bbi$ClfF?^F`*!dGlr$_`whB2}0t0wJM9H zrmnOr;M+VQ{992K3_z~?Qe-fVV(PP9}Qiw+cHvL)uxFOmdjXUVrR5_#*3o>ZZAv=d! zh(CahF*__VsrbcER~Ibv|o zODD^yf(%Eo4$G(owkl-&N$*W%U;V&*X&tsa@ju-d)nvM*g9^7qecuC@1|{^M^X^|w z+x6>I*mn){gsR5#V(Dd&c3hwlZXnvk#Xh>(@E0+sYW)OpD5({`At{{<=)9?S#5QD2 zkSQ8rL@%;|O&{H!qMY-OLy3or4QFSx;DBQ1FKcqW=NhIB89t75!63RBNereVcK7D~ z^fHjiUEo5L<)QRu2DAPEf0opp9B?C@9+ zxW|6l2C>N4Aex*ur66IqnUGmWS*0jm;A$dM%8<>p^cakGl927YsGVd@Rwxsz%=eVr zsS^Z)cea#xT_SviOxFU)QW_pO({rK2w!+W!nx%#Tx-Q;>DQ6? ztxs39lj3$Cu)0b!yEH?%V}ROA4GGpS-(?@RBXw!{dQdTY^VB z_GLzTFwx}_#{smT=@?(-D8_f{tV2Qt>CJRR8Q5TvkwDf|3RA!kN)KB16!SQANsZxZ zea{2)Ac%m|57}5zHk!O|9ziRb$xEeCv%|I{HxRX!=|3*|H$At&!!zy~ueh83KI?4W zB&NDW7UqTa3?vw6WSB7*;JMSw{Ih3h1bt6wRpfrlHSE4S^?)vO_|8)}qVND8Ivo1e ztP1v1BnvdX{QFGizAvvYPkj1IQf(>dYofzWus&6PSo3^jog+EgH||^xS;Z=ly=JXq zV%iUUou#h7*D@qCs>y9#ozPjb-&H|r}g3x1_(=1<)%cjAVoirXTG{M8yR zf}XADUz;NOY&u1`{li^z-pQ-KvA=@yC@$Ue;Zu|7u+o4&O&=K=u!C z5Cz6pp(G&SR0)hD{~ZE;FWs;={Tvfo-%_o?&Lcf4HFAWF>IYa@I6)R&^^h;2ubh znzF8C1qRu5L8~msAk(k>WFdQz zJGUcWUvAT8bV++kA~|K-LGdO;Y9Q?3#$CkQn((I+&i+|=NqUu)GwUFw5b)UgC+r?B z+l~a>_Hj)+#XD@pk##?i;cPLw8B?Bu!5~pp`DtRCfG6ie@B{(62F%ikQ-%e-q(x6`{6%u}}h@$%-P9G_`5Si$&$6GS5odG4G>C8Mgd;@h7Fr zOBzh|PQP+o_uR(+`JMaTa{vj*>8`JbB8osWlS?|X9?zb`ApL0@C(LoGjEFDdj3{ZY z=wO1O`l>fqv&ui>-SwgoQwz(BfgE_cv5PRZC+EPg%sXK>v{ES4oV;`+^!$e&)>$pt-1H#(K6AhtNGiq+zT)B!!w-myl#)CX-vo^~Jb-+}T3es(RvC^KN!foUuz0K1PmfK_f@jKazanpLbjw>w7nz(sPkS)_a;DcF7z3j+-ZlhCsl`kqXk^9|3x|w!B(Eg|J9nMx`o*iw-S&Q~M4}i1k~cETcF{~-oU)QS zGXR*oAWhBDNq{WU%Ac^)qDGeCld=-5NL~z#OlG8@6)!KREaYl1>?s=+i%jFIF3FQ@ zoo|fzChj2>l|hEe6IO>^uGB9S<{1*@G$k{nLygeG=6ED*0;M)HcDZ;dqWPztnRfQj zmcFp_jiY`&U8~=(JkE3Z_*W)=cl=exVSjCVa*^$uY z9-HB7ga=XOe+~|w48?$6OxgUNy{&n7bRFePLRq$9_VDx=dGoR2%$kN)@#{5Bn){-f z;1PHeN4R~MP3MF?fV$!Vt3aSx*DFJQo~6gE6(H$PG8$mjagM*ZUD|tmt45>lgGH5* zc+I`Gv%NGkpJ=uMuORc(Rjq^4&yo>cs&QfQl3mHX!J`L{?l~yyFn>J1P>)*(g>|O_ z*93{cMHJB2DKw{-sc@H7A+NC{AU6;Q5*9u}-f{=)5Mce?sdJ7ZAWBHmF%X`MD`Wv# zY_E1>A*UL&Zeo-Rl8BO$6v+hhCXLNT99+&g%YY6@^bY_)N^CnkVKRvKHBJkC$gSl5 z-L8^pT~FOH7y8w!tGdzdeu}ZKk$d6FcDt)(L!v+@I7{*>9AqTBVjqxIX{Rpj)i9cH zZ6BC*DS5*_bfs0jL{3F*C;^1!#w0E^9ftu*-EbUqC)W9QZ|cS=vLps-Rm)rAl!2Uxdd%2O^c`ikBc!`_ z@9e?xIv0zt^^toEI6*W7nQPaC3otElAe$f7Flv%y1X>t)kugm=LB!8YPJe>U_kP+z z$7p06rYJNSKVeM{rIXi5dk0CVu-VPV9Zksfbmb%-f~OxuJ|vB2cbIP*%QC|G(GK&4lo$xsd0Y~5lq)?(;T%rLZYOyF(K)fs)%IMGT zSrXGXJbK;kIcc5IqL#vJxwVqDveFND}Dm-u&CLqFaU9(MPi6KEv!jj%lrb z^3`Q`SQR{}KaCfq(!$fw`j$GkZ^e1j$K6EnPJ4$#^+FyV3jITu+|rfh z?#VZUQ+6PNx1V;qE~&o6snZX#jp>ANDg8HR!Me>_`nqxGC~e)!J&+@SDSbGV@Kdj3 z_KoK2EL4;GU&vgk6{$S3hEc5lGL9Q6tr8aI%vc)JrA~CIIqp8G1#fwQtu;GN%MXfd zWyoWtfU?yz29imoS!wp>M8@yc5Z`AX&DBKE;;UdNtHK+aKZ1OdO2%^B85k{poAYv8 zjo71h8k#DalC;VkqY1k7im0k6&k`H6(hlDp)-aTj?i~0A|UoQcX_u@4E@G6>;csi!LPDE${Tibbo#jnxV`Lw`Qk{IgjUEtjgfsq z^&VEU%p>g~U}5kH=i;P~3!$W^oI1(Wb^`-ajORfhdL*e$!bLOzYWv^BOB3eEA}wcB zm)H&lW);(_A0!FyW(e;*<1hPw*tF~^1S1Hh~k zR3#H>3PGO6j$*z{X)`9X9>Zg|iz#$7+wle0AU`^AvOFQKo&*wvUh#)z$#`J%Z{?SL zjk{@4m#e09^})O*{7=tSLOlb;_M`@CA6e!{Ch)c7ShA12w6{k7qC|5Yn;LO}pTq|MMErUl0yy#0& zYCgH5>`61VCo6=M`!336&JR|jMODZkXTB<+6pJcgP}Ce@UQZY!eFc_xB0oGu)rj}F zxCV!>*jXs;8aU!=KPs0CpCH~E)>!=vM=Bj)Sg%UN0KA~*Zb6axAJvQ~sx|tz!V};K zP{gC9++Fbig!RzC2WpK~Y_GacePi}rw1njR$L|U)@)Q|hMNHY*R`zUvrk})>fq13K zMypQu!u&wsHn^{1Ckj97e|z}Yn`GgM=v-$bsUI z*4J%KMV~~%21mo*YDh<=^-Wv03YDg}9u9{TPS^->u%T@qM^hB7LPZTF?sj!1*R0=8 ztrQxq>Gj4JCUlmtWvAqIQVu>yYcJg)C7qcl-=9;qzB^UHp28MO;wRK|1Vq4_i?TpE zA|!_L<%5iGRBvypei}tDmaCCZn(#hhN^ZY&2gwdoS1b=X=p|ut>Y^Al(iAKBdvl5f!`x z06#zgF%;N1Sk7Jd7qY8@_eCzb7x{HFm>MP@E*if4Xg6QEx@8qhYSjDin|j9V$|pg1 zj0?P#I_U8&qU$btp*4NJNFjM+_*v(z!b|yUtU67#j#Nj4`rt2dv&*HVi+h!rx_cf< zk*CFDrcGyJBFdZT5|BnwB$oql^5I|=ATQj0dOtk2v^3o926ETE`hnr{&?(k$($by# zV#LRf&@;f-9xDB`%jf9rBR#T^ zr_LU3oIT*BbEyg;dYV65j$7%p@l8DPdH?HHs_EI3HBil;=sG*A^IC`dcvv7+{@)Yc zev|nznsMWBn!D4<>aJ0S4fdGZ1&>$PZzqSuF!VYQjlbkCtZ3!}V2K;>cxPo(S9;px z)$3NMDU;`{-$uEIF2WJ>NZF4lv6&$dA0_{~UnbhCF{7V?Sbf#CcC1a*dTiYU0DbyY zB(CD?a5)Mqed)h(^E2rw%n`~$^kS-NZwoS#%|Us~{5UI9AlRgPL^@eIWu|>(+$S*w7vp4eh4R4g|v942&xS!6u$2va>hQ z14Z%-M0=MV5X({#*dn%SjBCH3&6F4H^_KJaI<7x@DQj)?kHb&HrJlC>S;2AMOsUiN zv(ZI2MwQ7)pJ%9!p!-{x*OkM;xj?|V;v#0*65MS!vWnRf%T6prwena7jQa}+Xmmmx zT+J{jVM`Q(+#ne;Vt25NK^e43ZHz$~u3?`surlYhfv{Z)0c7a27))9_jBZHx0v(n1 zA|bjAYgQ$n!-iy?y7>M~z{r>qf7(p6>kuP5>Ovv8wu8Bd%$W|mUSZ;T-bmm+o_<=% z)WRiReqD*5CN!3Zs+oj(+FR*P{(W>ri`)$~WR zgfd6~kPlfx3t)+fC3UAdt4exISRi3da9E~I`l~E@NUJtvgo~UYk)3`Kp*0E~h)Cwp zq*>qgTjAfRv96qtaqTUG%I4uS2#(9Sx2B<;6N8xIaM zA8-WRNZfierW4R4gM1Sy>~`(wU$0}+I*%NcT)Fp=)B{m9y%hEOpE+##1}aXE?&V%_ z^+P-Ep*o+wt%0%=+nix74zqcmnbe94?FuDtQ7;y=^_dF{O=uWm$wy1(t?LbIgb1^9-uci#LKW7%LVDb_YWe0WZASBbPHn7Q;~al@@OkvT*Rk?cUaW?oNy{MArvEy# z6DBoA_x3zQl(A3;Z;S~!HSOFEAI$Hrb|=i zvf(DQ<)4>ju`f=)d9l6skD1mH+8_Ufqxk7{E~}TV)XeclT%#tV7tB|IcMUFu*=@^< z2?He(7eyK^ZsLoXig#R5qxR>_XWjnCpHBtnpu2!jR@jTv?Pf~-lb?cj+Jx>fuU~W# z$q`YH82>VlK;gyU?g8iVZP%HO28GWjhIovXqgw`EUSMgPwPdcQ#TblN`z*CMh&pD< zCW)s$nS82m)B8=;0HcFiM>j38hA}{SdUvaq_I{Ol_N;YoJ`bP3^4%hA3O|nMvcEG_ zO45I9WPNq5F?=o5OHgk%uVwF-eQceCl@G}m0~h$5$A;#UKX&N%9PT))ub67L;Q=a* zK^kXuOxcQ?_=Chf1t;Ion`JUf#tSUOHvZxNw$2j<;GpLn{aJNbEk{_Bx}ZuGibOFx zSAVqX$3SE`eWat9Jox@5JrDjcUGIk!POG5m1g0#UOM_2+tp<=`mNd=pH5H6nN8b?#zvVsjw zv-~pudl(6Ub?!U||I5OW*3qi|6zRAbW(|~W)m%Vr0su9cNo89N0J1NNBP__7MxtX( zivhhH=vGDnZoxb-0zp{HvXFZ~0?7<#@7RUm0`EZPI}2M?1r-3W0gDWIV%Tc!Fg|Ni z$z~%>($4tNg}(fUl*mWp5+{7jxIXcq$A0)(c1!PtEw>Y+uUnpr`^+kNAI>{-9xX%Ggg5Rnx{ggeP@Zx*ycObc@ddQaW?$Hj7?7X9 zu$_T;2a?^v&oTlMIXoSlKMgJ*RjcrR5fK19;q-6WrjOg+aL`uKYK|y56aG;GBCzx> zXSF=pN;_t}tHvl}AfDMh`{|d{iF2^|2)6tTKVVx8e7JOGX=P`Pw@dA6paP@f-O0u? zMeM+}QyNPfKIW8k=DG&yzV9sn_AD%aM~G9@;TsT9EW2G6 z(J8CiF%Pt&C-P5vIxN}DhghwUlNf}EmxDx9p7lIu?RiRhxuA(;XS*?IV)$ zHKM8OdFg_%o$hooihPLJC5psS=5IK;okUM`==fS7)vST5>*;#WsO12@@eHU#iSN2~u z<8PJ;Q+)v7Gw-MwC+XPO>DMClp9J68|C}BT?mGOse$mu@9$gmeF`nBAi;d-PB#{l9 z;L;e*pLW@Q){P}62Di4!CmSXa*YTOG10BS5<~qpOF**^M?->DN+MIQ*$~;LrbjX}% z!a78h0DPyRmZ09H){enlU_*36a}}Vj>4+IhAWFso43DhSYB8j_t@wDoxjdq~3ae%J zE31t`k4eBM0RA*uY7% zbzWHHve^R*>~;rGake$$39JCKcdnxb!P6ng6Qll`$6e;} znGhB|xXd zsJ^IfwW}?6Hkio9T@rd$sv?c-*$&HStfZqI-9q*?mDE-Ug3=!fuKmZTAm(ECim=6}ni(<9O7Ya%t`*llJMHB;^@W8;@CT3J+sRoJtq@1jwshp#UIZ2wpMb=!dZO}Y_atW;c|5feA6CA%m_72 zH_G8?FX?k`z$YekvI}+zvix3?Ea2z4a<|;nV$9cE++LQM;2Q#)*ftL$`eJXXi8mpS z{Se)*AQ&s&U^G+y{`&LCR?98^z@M5teYbYzMQH$K(U4fG7IftH2bYBJcgv%&J0fO( zu4DUH)oaWJmNBeP)b{4C9P%4An^(Ozy_G>^-@Zb`za9V6X|2o7O5o>L%byQaiFfKM zQKyLQ^MZYKQC58VF~}vYW?ZS36Gi@Y^uhk!Hqr%8531#k_$PiYHmAR#Zz zYY;-=??RV`yK5_wZ*JLp^!=GxEm+H^qv(~rA>837gU9q~(bIbN7DlmZ?n(U9z`)PI)g@hAt0P@KMYh&9U(}S}yC})R(EB z`}}3X{l<#b+}J62kqUlI&m^GO{gps`kRj zBG@nDKF|fze^YIq3v8nqGaNYhLRAG%AhBrd=)ePITzIuc18 z?`LteCV4-oo#gTLT$#q%rg8zsO8@gh3${IP4{XkuFM*lSy^3SD>f19@i zNnYZxLCvN=VcmBg0!?1mq_V(1L6@2U@@R&{x3f#YCai((8(6F(2=M+%M4kk3E87+t ztLW42`o^$xvDi^BKVQJs{eL8#dpy(q|HeNv3^~>mno}wpB{Jn~lCvB}xFre2ba0sC zggMumv!dlNYz}ox2SNzRsltp@sAO_X$Q%;x-@EVczj!=6!tDKdzpmGHJuk9KNn!_< z#4;!8y%#V9O!g2uC}E93=EybsVFhn}$r<>-JPf8G8NFYACGm-L{1S2}%Ns~UQ zFrP1TR!M&lQXVF2d|jan2ErC>_d^^>LH$7VWH|kZU1I|1SWC6;evp4xo2S^r?26;5 zx_!Ezb9|y_bJIPE+h`esEVg7_Ek%NjJu6S{u*D=W^+12pj*|np!uxgbfCU%Q;R_jN z%xRX@bpS;QL11D)PmqQ26k}_gfFFHzB0ho+=b>l-0YTGAD~mrp!ftCh;JeEo;y;B7 ziXpo=t=of+d-N-wU($i6B@CAYGmr{D*Wr|c&z5kn>^X#_z@5`njjkJ%QxH!X`)}%@ z!J$SpYMQC%m$7(|Q?|G8`#-I&zYxR@_!9}N!?MH5{wWpIReWYz$byWZ z*GaFB9G+&SZ}0BcG%|L6(09Osb-4Ou`*m$c%Hm6u4*zell9M}$Xz8z@!ChOGm!G-9&QRvvlT-sNSO)p$_y?| z{s&!N-dm&$?MjkgALv^B_ZqkxaA( zoynNfFjb_))Fgu!l4uz>@x`e2&&k_ruEIy!eB>!Bn+fivbq-w|kMw2R5Br?=c?Ne6 zXaEq(WbBMt(|BAT;Z`bKsaA2V^tv4qwKj`OF3ic}JR*GICIVo8Xp!i#ot}yMV&z@I zsrwA;$Bel0!_C!ok}HL|QQJii&Yc(DnL0~M#~EwQn@M4OTY2L zX?k7-1pj=Cvok$l6OHh)jjYX&!UwwlG5UPneC5%{EjMaWu0=p+pwXJ!#FpIz@3JVP zF8;%h-p8tH+n+ik!Mt>Fa!-P>!Z9o3573#=oM$Wi@D30f5*w23(FYEP`-rJ*QNRO;Z23h zKT;`o^AH?U#dW4U6GAX~63FO9AitE>%2sTGu{{T7Tv`iBwM`{h7rB`Xli_9r66jKg zWA9B+S*8lYE5lTvIvC87o2KGTK~Kr71y9_(Ie%`mI%uP}?2ty19n7tC|FC^P`_?qY z>Nrrs({hM7I-jK5oPI^nXw^T4HHrLqF%vxgcsFB{lI8UAyG2D0hmx#rKoGOdX|B{` zK_q+(c26&2v#W-t-5 zK{z4svoJ4^c>j5B^Ze(lDh|t0@qA`nIw{6KQz5#8H^|su=K+u+loeP+^AA3dTGTisJoX;Jl<@{GdJ&p0tmp`Jr^a)sl>5Q%DWyYo_p1j-b+> zTM|bG6FfGY?!5QD?V`E=sol9)uMB&8c<)h#67umT>+rQ>qF=2usp}Z=bq9*Z#MH-jgNQ~5jcBJZYjGt%u0UU zUMdAA#iL~QH#LBnp&tMDrnCtpz#CpIy<)50u-;njHR$qo@S5YFC+KZH$nCF$6hQ~> zw69fgnq~(id1nG|o)Qp5{T(qqr|Klrv#j)krPhPGCL8+&`MO_K#oRXa0|0Dw)P>`1tX2ME@a{@m=i+b@xn)!Yrf-e1s5(Bloy5E{5KHHF-2ArB_HSG ziK7M&hijJj3$7xJWdMZS*bKAeQD}GE#!S~IHc4UW68U_|6>1phSZ0RQB$KtR|1_ox zjolY9cwcg9_miCKSMw8QyWXhkM{t})YHCi)C3%Cj!TXl|;8PZGu_}|D(~v|fN@i$@ zt~z0Dws053>ssA1`t5ts4C#)e>Js3NqNLK!8#3|4JdtZJ@JCu_{@%H*E7ucxA+L0y z8FG+U%k8=ic6CyS>G@K-+j5Cdc50tl;-r<@b4o^N3{6v@8wS$ap+ z?NCwQS_3x!A%PV{OVh>P@12X0=eGR!ga?zx-Vk?2V^guy`W!5KAG``uy!SDyuXk?O z9(#@bX~uxHUk|hRc+`~aH=7AC`kol5-IL4EKZ)!y7;Mj#CoKIeQk={~?)k|t_N&T< z>Y_2Onr`&!`FNpsn90V8*s2iDBeaYV7?*`i;0vbw2_KkHP|@zH#Fw&^t3+YWDsQa5 zONP46q|kcNUbpCHuSTd5Z;zN6uU@#n>5`}p0CsT_sC8uGk~xw?9kgg$FS8b}FxYgA z$=Qkn%_ZUe+H_vkwo;~^K4`0JL0D&XCe(ScLEgqJ}vgp^cSem46Ks91u2kyr@1n(`S8Ft;N_oBenbK41%Uu%&4h z#ju}pupyu@CDHkw9pru8KHI%5@Q4xQ;jmQa@T*q!K7YVnpD*;H36GZIZPoW3>Y~6x zgYG&2_IjF@pn7l#>>aH;G3CGzgo$z($zbse01b~1(smfmZdRo8F&UhBbD*BfR~W zTrq_ZhpE5-p1n*LoQ-08-Hj*XX~vn{a*|h^I<)MFyFUr9b4vusymM;rKaUMsoZg`4 zXJ}Ah6A83p*hJcA0$Se9Q?a!6m=$nD<%!mWfNOgf_BE1dDlMN1$zn{EtB_FX7&}~_ zBW@OC;R+kfwh)+Pok+AWJqngKWnUb5CXs%^ zJDm>2rbbd8S9>p2)qT2g(krk1cx1{BZ+NU5|J7w{OItdBwl#3pYfvB$ZX$b%=6A|B zd!sNw^L2Pt+sGdx7jl+TY0U~+eMn-Y5-UG@=JTqdgNT?@N;A1$JqPam?GsboK{-V=t{~}P2O7my8fUQc5 zx!%iB$0N#AKOEu5{sHzN zn-9PcghbvxoRvdlr{%y}H%1O@zViVdO}RM@>hzTV_d>*3_+8~~+M4reV%CGMAu2o4 zPv>LHdN%1Vxj)M23jPF_jc|PhI5Lk1!u5^8BO?~W|u<(Vh_Q$L*2lk`OWia3FgIJ-J36nVL^slm@ z^!rcfuosg;<`>C&?3Z>*Noy77lX0Lth!;JrKe+$rq+HF^C|L)AWovNhnfL8@X=0Ov zR!~@)*KJrrHaPh$wR8LMuaAY^`Rbd;)91<>AFRkHJ6;`H^ibJ z9LmKmrm&x=dLX7eja!xtHn05BzfGl)d2ot{uDzm|hX^m1p=vCJVu4Og*>U-tqIrY|fcdCN<%BsT!a0hQmjO>3IN`hK8zGp?^Yw#OuXVEN50 zr|?QDDSYUKEw$@^XpYcxkSR(&Ql_j{`Mss$5@!>>!Q%go#p4rzrTlU(Hs2oHeNBKY zjN{|E3nFAtht#a~4~z(u*wcH=O>-W%fE(SzR0HO6DLRgX4_{>}Q9$F$A!Io+2l5?B zFaz_g5L$b&gFgeL1!QOBhVHFmTiq}S{ei+D3Ur|gK5r^p0qunNGL^x9(ov!2{iU&W z(h0m$Z8QF^@7jOkWwOqGoD8d&bCXI=VCVc9jFQ126Y&G-ZjhCcieTv%vTzhzuBIlD zBm+Ge$p~T24pW4LE_BAxK#5~YXM?BiRE@+bz#LSmdT`yVi~caVQb5mP63qo1Cao}H{G5{f60oaXChJq?oN1AV zu0QHXAEG_7Sg;MYQ%1%`E?8u0E?8~^S;qsN3Osd%78_4Qkq_;_n=( zo=r!d@#HR#A%O_@l{Uk|oCiW%Z`;-xF477LynhDkGCnDAr25@F^;I?cmc;z;NU!q| z5QgtvpM!00v<3at;tI+$Xx_qagzdeebp_e=r9iW*6z=h_u1j9TwO#XTN=Bi##l=dp zw^awbtX!m8Qjjso%Q-@x3MF?zNfyZ&ak~$DSe9lg`I6+K!%^68YI=m<_rhdn-o4g( zhrL!D1W3n!p(l57Y>3bHTPo?VO=Sm$@tsWwm!h98!%aT;DJ_eub^}(JbSa~G+JBJB z@-KF&&w+=#p&tI`y`vp&PGQSR?kB#Vb%yPKWSB$I)t^YOx+uSwpxSfq_kU2?H5)l~ zwq@&Gd{E&5EQ}R{m6-zLMOQU=I%?v+tl1Z9fr||*YWv=vnkzQe7cTg0B;*25#E{{>%D)~= z89cJ*7^tgO84A7s=V`THiwiI@Wo+zo3ghi36s_lh%WBQ*;DHL)n;B}HE(23idD2It zl&d$D_DjXsm6vXZioxK&7{JXw; z!9G#IR^V`)n8H)C8K3E6SXx=LOnd9*rJwh&1h2R!V67(k-Fck$j8w^|ys(Q@BknAL z)d2LX%tL2<(AI@Xs^5q#S-%3lDY*PM_iE~v0in3L)J^qAhI;fuV@Sk^j5X_pFiG@7Ss+zcL;! zfUOzk;L+#~U;zk4eaN|S=J~JCk7_vRi~#TEorAGQT>h2!|GQE=G0Od;njhUGEw~Bv zUcfQBD@UXm=LgY(4%}}-7w_)8Yp}uSK^!P(>qq9N5pJ6FYCT0*g;y!Xn?mMApxBQ? zB@SoT@sq_XrLiHC6dk%3c~7-ffC9I?5F?0$-o+rrqrCDh;9qEdP+OlZ!8)izQCUhF z%OeK7^NwV$zN1Ehalh0oP6)T)k-JomZ}*se7bviszP*3bg~k(f?xpyU?Y)UBn4VXf zKVsL5+s43yisR?*Wr}Q)$qNQ2`5g0E?Et zo|aN+I*Vw-C&v{6ULvw%2QmdjBY9RAje8Fr106&2mT@3ZB+8A=$Kz3huvWGY9@smD zAdhA=V+$jqu+OkY$c9a|hx`^gq>zESgR-qce9|0>ZlK@A;9WUi8p)HP4_vEGox~uD z|DAR8zEk1nZRBRsZxv3uX7MV!4hcq6@u~D_Q{b}4g7h9h$$0C~?e!ceLi=jb$b?$! z-HU-5tMsf%!KWJi%Cy{(j6h8E94m1Kqb*CMISyy6^s2)tIt;A572id>X4zSE**@_? z0x_-wnaDbP6g2=WI4j1$=K#X0d>z2+%0%HI-~q9%319oW`;z9CR;lkZ%(+*JB?*Hh zrtTVJA`LBr3@u61WodlGOVuP!fhgx6N0=$J+$-B?AGC<0?WyyhczNLS)xm{panf0* zx@Le>P<_6dr>Sm2r2l@kK-+}Wo!C8Dv3Yd!gOP`6py7wnGwGEfWU0@F_uKX5oRk$o zaKRD3TR@7*n6`uN_Y|GC`q&Al6u0Ugf2ogy_!!-Xh!$}B5w ztEY7dw0t`guy_8ddcY*2?oH{Yv*K?jkuIHCEB7TvAR(?s|4fx+&(I-dmS?P0^7#PA zrlivP=6js$5Bl4-RMk&N`DV}B?#6VF7MbAkwjN*qXs}|UQX!?hRCfI!S=8U*E>7K6 zk6WhrDABtp*6OV94YIi$cdr!ZU|d>F>yLAO4BpmK3?lg_!SJ&C^^wwMfnsAFNbGtI z_xyMcZ?vDc*?&-cYxZl643leS%A?d+H*OodX{Akqq}ApCeSZ8^y{5vtF~+~=4ri(@O5+j_;}- z_$A$VJxA-LH&4mB@Og`H@yEw9v&ze5RWwwOBytd6^_@D*b9$vcbhC7a^sfqAcD0z` z+?_6HC8I=1o>K{Xpx4JUZU5YElIVxvHn^B&omJTmSWsNpQx0E>LIV4dt3^A$wom6y z)Jnmt5{rbN*E*tjNbJ_`TvkTMz4Mj<9;T|oYsTz?k<3VN=W;)ySgp03=d-*gL)(wF z9nrwJtlfourJLCyU~~5i zF+iVq>`UtVWP`LTGXi6lGB1kmkQKJCOh2Jg*Q-NW%71L*ypQ2o#|+24D$Fwakuqp$ zhW+2j%qUQaM;fYSKLN=k+||A2(4`BlE1P@HA2Yh+I5fV`?fe+8kL4~kgW$3ZdHok; zi;mN=R)tRJALa3)8V+)Kvgkeg`*D8C29*}8Wi&7N2PE6h2ET(8*JZ&iIur~V2X9Kv z)BI*x;L5CjnMUG(tqV3WoX$JVrsAg)&K!ZE?0FT|I=07DE6>2T6*K2rc6bQ&-rzSSV#AAs-JiqI6M$A3s<( z;b|t|mMYdPUj?$4FdTEy5(k@KFz3%6&XK?&ka>Lsi$$8Q3}l7ZE}`I*huGmvP)|wT zo$hb1NjatSw~^HQaL%&%IEKu^5Q5D8A&iI`#-KtrVb%%*F*{(M57sevMD;=+N;6dJ zJ-J#(MWhq)-daj!ovJqaPFM{c#_TN6cv`T~moGKpQxt?1WRQ9YQ;M?Z8_5=Dssxw9Hy^sN>#C3U)X2+%+_s<}MgO@AgsW@*Tb`?K>%gYJDwj>?a zE>oBvrU(GpAB7KPPGxJ);{^Zm8)wiR&|xqY<+JS}4Dq*vnZYa+iiHejfTIlo@Az_RiNU`OVBgq79$%z-+{i9lMdlG!G|L&X7 z2H@@3voH3NF7@_k|KeOmd_}pWJo|p@V7BoQYP=M;te}gXZ@G%~1SoW@Pudx6Idx5A zh{`P;1p1CbAX-`nyWRW?-6{*J*#iw?RZOx-j%k+PBFg!cz|;J}XJhR3cH*yeN87Us zD7l=(>*M2KTS(R{>MT50tW2}ns)sJ;TuN3KMZ-oT$6SepIj4G7S+)*t3in4>kAaq2)4G%eQ}T50`g z;Ma{(D#cSl3f7>oR_So|zTd$;gEYSp?{36OG0f5=AtQ=}=M9tNOS!Z?I9c!{uK#M$ zPHlKeeLvjnq{rK_9~a8MXnh33Hu5MyZVdy-1F#VJ1A_ZVgAwZSIctZsM_t@UPwW4K zWX18_a`y`w)^_b+TRGHDjmHP>7@dgdJ>iZKt?!xiPOy5HrEXszQ0{*+wOH8mX?Bmk z46k{^r=ZR${q>Gei3pil4)5nzaN%vXomT(eGv9ht$%gj)hIi%ziM+8t#lBm8^S&hq z&!?M2io*xQHU?A3d1dW4>SYDe|2~Mp)Di}mh#m5As<_OQme=Cm)KIJc|7+9gugsGuefuE#a^d7>zp@#rE4Q|X)I$@=Z@m# zQ$F4+dV2T6F55y_4W8|$H&FhW(KK0L)yx6I2+d7%6J}2Rs`Y+W;ynWLpa;pNZs`~oz z?R1ej40Y$*eYyD+vF~mr4=VH~u?*ua)j>lU+Y9E6)^TB9F>}tQi))f6$Cp_qcE-F7Hb@a%?xIBhVO`G8`wOWLT1C>6Rg5k@hI*AnhS#F zi4DXY*Y%CatS|-Au#Vesu>7Dy=VkI|BTE2^M9dbwHG>t_G(Vipgs(7o z_hDKCbp!p2d1`KoGUQf`haQSYIn`(sSs7bJbR4n}!2%C74M@HP8}tb(C@hKl;itb! z51qH-C$St1o_=5Xc=jvP^y+;_gI=qM2NoIgW_}CCTBr8N&L|t8XMxXp!9s(AH&tfm z{VN5YP=!QeF8v77VT8hunxJTcC0a%Y(qRFI2=LbnL^FVAjSqaB?hk2qA-yQNLJ)e3 z5Cw|CG)%!Ie#>5O7X@7!2N=S=hc&G&&{FltWQrahPFwEiu3MU{5bM?a*L$UBn=euo z+-(*&yLOs7{# z?GLg-fC)?#wOa0z&V+x*n<|V?0@9Dgbb^J6`sBD!V5@s!aw>!RD2Q7INo{VG)~Z4J z{8Kc^WYLk}V(F_CoPmUycEF9nutz_H;rNTsx4%S9C7z*YG^W==r_IK;TC6fnB$ZKe zHOnaKCxPBMNlS*xcUx@$oe*%6oH?$|gbS;OQA5j5KP)I!e$t_Ox+$m6g3f23l(sKF zCWIUCdHdZ;cSXBSC(F`d2WcAw-o$ zF_4G8r)if7{A}W9%+{%qYT8JvuM)PeRCN$villn8(pZ6m8vWx4?xU0nhW$7}b0lrZ z(~AsSG_(6=1+v{x!xT8Uj-cDpO=@e zPDVMU%}R;3W<_y(Dy*LIM}NQhqqMj(p^*>Ie3mBg+mxq%0Nn$VPH``MKfe@Pk#005 z|E4L`zEU($=occO?}cjuG4RGF2A8{QAE z@7mu6F0-+>Dn>g-UOYbR(+O)$CB)rA^EiKvtKkd{@x8n{`U!PQ98tnSKoCVqFPxR z-Qn@2>V8Xe^>GyZO{(mT@}C{v)&2CjyhZL7=2hRPn1v>jnS?DgZ{&3QXkxnSi*#UV zS`UtvicKXcHpInn2htx30Tj&jly+(x^6H&)ap?}*SKj6WAe|mt`sd+IR_KewXrBwq z6<-|(TNSITlA|wOSgsZx*)?9Jm8(?d$8%-7C7|B^>>VFZX_C00^n-Hg`9V5!^jF4T zqpe&GD{t_}m8OkLLAU?RMCto~UGGu)yDAsw7|d60M5?E}ev`O-#HM}|Sf?cBhhz{| zn#RTya2EZ2>ziZCKz2@=0~`_&@lzvLPR6-mF9m45S?}(Itv_ zznNxqF4&H5PG|wWE@H!_EUtHZ0N^bucJ6##DZ_X`GPZ~KE`LlmZ z1VHSl12lv;MP4{WW7zuH|FkMQc@Zq6vrkzL2#>1|pYr6elscLszumqd*6TlPH6eW` z;rg|&>PF+SR-Bu1wF?&{umBYs;bj^By(-Vb=<`f$(X59`1UAJ}R-M2MBrRJP#SqF3 zX2kc@z4RNi!-mcFLN}TLVkX^fwLfX|W|3w6lgoPJ(Qk}C1?v zJ&fv*X$oSzz$iX|gE9DXLGBrOnWACAtIsVRNmw*h=K;M4K<|NlrD>Q48Dk-b;W%p= z;-bbpMSu_n4e6k zgpqq2LU%PV0&7eqSpr5FpcaowGYp4>pU|=neQ9;_oT_pwKh&&UmiX4>yA(16JZ1() zDt8}~>OkS6{npE1=Kg}c;EFBgrfCdvd_da*fJh&EJAV;bGz1)YeF!%}IJeYrNQ_N^ zFk+7|K+1x3gM9k{4&h)H4dwx3I(*(t8^F`SdRD4+6-fWO14F=LG{AEBl5v^5mtwPG z-Gvk#2Xcdfrgg`0XTkkCNmA7hAKi|9u1$)`tll^a@JM`K64!XR$-t2YLoVHH zmM~{IZqQe;d^dfAP`i!JJUI7Dl0$rEI3*Nw`Cyjn@ajGN0-1&F0|DPXa6d=8-ksPa z*(-YAEZOHBPZC}^b5l6KD7Q-Q$Q##j*qjb_?5Bb-aTLXZze=5hcJ=E#uOuK-f`kjqFV#K7(xR39nF0ihhQECNGW?*r|Qk+ zL9eL+3(m!Uxz$nHH~mnBeZvos+27Zu8_Es`XKC&YIHn-xM%tI1(S>+!W~7^K)X)_i zdAQ_m;3WwapERbq)hYg-tNS2shk7=2a60?LaQ;6M!DnyDru%zY$l=pq4udV&R}*?V z*GBuyG$;`fG|fA|?>FM5q>HY9uJ2bWpSF}qyeuk+Qi*S#6&>ff$CLCXEwA$I$;vPk zu`r^mO0!QW@hbEu-vQY;mVBPEGKl4C`{#~pXK~7-k&AmYHN_tm_S)SkIBYMppr4^@ z|E{l#?%0LUp{pHG2z5CWtOvIX&t$ZD@goq;r*As+D1S$hyyvZ6UyKPf@omzHu?HSkA2l|^=idC z$(*x-Y}kLbc6~g z#Hal$#!9deqo-JTtfFiW-f|D|l#0P_3hl$nTtkvQhIlm0K?TAdbB+aY$JNABFyxxc zY20M8@HDt^{^gsIHG5@e82#8*F*n449EveDilvAym&?iFqr6CZ`o-1#+)33VS5uaG zUHWo0q|^@HisM67BAy^5xy73mE$c<7b^{E92%;5d!>8% zxsP*Ku~McB!fL`$#{a-{`-1AA2-NpR-gESTPd#!LWQF?7L!2_tmH1mk+Xm8xGYJ zhyaI`TC^Vrn^P8VLbL0P1F#J@42EdIi=cUkC_h3YTirA}4uKP%m`(z7j2C%t)?Eq& znp|xptN|nroc-WHU$nLmt3ryl(cUb}_J7hhic$+aeaU=idHaep__M$1;&pVdYM|{b zQ(Eqg;7$bHJnz}}=Go(sZS-|*`kul90>l$E9G4Z;A>ZC>-~>3LD(lxVIJ~;+1kDVr zU+krb9gxLMgmgb?Ri0<`<_*I`qX}5**SiRAwYpv7k1HRy^a9qd@xRd=GLzZ?S57w} zEpva5oCM}kb?~iqVssq_s}w}rhtt2C`RUv9@4J0TA|iM`|GH4=GH_des6O^<=+T6Q zcIOE9n5;#+WxS-)F?Hn`pc=TlK&(Y=k#tW?mR8;g@%*@1Dk~#_CD)YgP@>>vaS0j+ zh8cH$nDHi?=d|gsmD*r*yXJ0^Xnv68p48VT%x|QX-T8D#ba6k3fAN+8+bx7O#d1&?Ts6G1Bn5_xshUbkX=ko+n)q*Ldu z{Y6*;|0`cOf{D1YJMH{qjly`c;6XL|9TX|Z;o3jaFYW)0TEUkn=q+c?5dIjt2PO0c zjpT_x&6MNr`t=_a;fuX*Qt^hEJyL~EbtEWM&WN~tQkvvfxxE7R`8cc^8`fW@hbJqX zX9hK90Jmoi#o1igrTlGAF*vm^9eR-fXf%U$Qc}F*L2YF>@4+H-_9EiazuPGt%Z0?e zO*-9V=fX*q`YcH8pZgba4KwGMhF>PE33px3muBp#%@|KFmV}+MI1(&2L7XAlo()wN zZIYkBYLxtV@ulnsV)SQ<0q;A+N|~(lc3RAb;CIc`h5mV`$=`YK_mOLiv8sI4>*Kz) zs=`mUnIT_E6XW^Z72r(NYOcSm(61^y`Mn3*rl^g=tahF`HD^s`z~|79#c1E&`gDI% zP9r($cYSV*RIcwwUOUg+pIa6gRqxn6hanHEed-ziGZfI`*J)V7P}%3FgP0$_6L)q} zti1{{uG8kF5qcJT^$UMb(k_l?9VcX&%>`xK=Wn)nE41x9lQB7m|AWj+?QVLdc zOh}rsXcdzaPZpkP8l9+0_IlbP6odB)MpP^Pmf_M`m+xc@>1#wuoqu=ppxuL&t!I{T z|3mFd=gzMBKDm9OE%w9KkrrA_RLfqPRL-!0Nn+0FmNVPv`I!CE!n!06OCrj_wP;UMFI4XF_mJ4 zF@>NYKpKK!A+Nhx6i5%hhRms_^G>A|_;n!pUQsmq2pYyXzX>XUx-}~ZSzUOO4M;;( z04u;{()oHG)CF+^4N_e@gd1}bSVNCB#hS5$pM{<{j?kiMH50F4D@snESrnwyCF?z{I*A=D;5OPg^x zcZq%%0;Nb4LO&DT3n77U4;!Uv{Km6IK?AsqgXN<6)oI}R8^Xt`xIs4fZ35u1Ct&|V zW6zT9(R7wV7ZU_x;^L}LY@`IWIL3dJQ%Vn#`w_eOs#&2>B;o@l!0^+AY8OJK`bo^~ zE-s@-w%qH8x*_=81m#^);jkg}>zD{mO=}+Aeeg)!W^6bZt6H1U z=ukkmh}JNHW-wj#~Q z93LEa^>BlcYUDxDoE}L=Fsv18_7iy*o|d;@CF%6Y#qj0OZ}De*rmb)qW(crWXcqnFUAfJzYMJs_l_8YSHuOAQWIocd0?1M*{`3JJP=p3F#iSg5O0r!o* zNUUtl8IMP()4#q6)L7p~gC^b_Sc34ex0$9#&UFU9`$G5SY3y7wxX%gg?KD5tXwI$N z)8;H-w`n>YZ357VpZwtc!=I(iPI}5uaFCzdrJ!-KCR379gyxw`BW!mtAl-;Hw$k6v zgvCEo@6^d)A@WOAHALH$$q15u0sD?pof|i2DTYdqE$x0Ca#S@o)k^;;qoV6mIDGC$ zY?Xq3!&-LTev9#mltU-TE=R{mE*0s!{N98|-?Ci4Y&6V}L$UWU6E9?9TYtqVJq*Tm z*(2QKLM|h&Tr*hqsKLr&NUp}|>xBQHk1u?sAJ=h)H7vyB1Om?q>CBPX2a+B0x37HK zXZ6_Qu5=Z-VE9$YgHB6DhCNz&Gb_`b3Ps;gv z-M?+cvmlqzkmiyefmebu?1uh0-}+Zx`doDNtGXWQQ#x?X!gT1uCd)>ajvck%{;DtF zwFGd{!rYP0A4Sonn;-5RAJ04^HN_BfG?Kh(%&~1Sa(26N<7~}BnT=f&J=W?MCmuvx zqGul)sBgI@hOphYeF3E&{JZ~*JYYTl2d!yMU24`Ywk0j&%MGb}alWcsXLo1SZ%VOyZ5o02cjS&QhSjgC|LA)hVQm zmZf)rci-K8~iQ`zzKs7p?eK1;O5PN?5~5Ykt3-49keI>kJILrAxINzD9yG`XR5<3&7$y| zES@lCAD^;qjXkVw!J4{^+Xl~o1g7FvYoNYK%K5Jp-j~kU0MI&fv*(=8UBz7p4G05%Wsp2sNyd@=>29xKGJ773KTUMVnqc?0E$Pd*72m2v)^LJiF; zP(u0{SMpoPn&`l*uP zTL$P|wDgJdSMx?GnCp z==HC?hraK>4`uM%J+5*nB|Kzzj)6F+a}DjFk?+7&mavzkQC|Nl!1CHSV^Y;x&dd1kg_xAd=V)-SQGa4EH`T+Yg$yj_7U4HX`tdj9xMQSH#0Y^V_c*uj&atGjk ztVa?6^w6M!x#_?r@52_vNn!-HiXF)*DaX1^xm!vO)Ua;)+1B*~oIc_PEFR>&i$ap*kkc_qgu8|45pb17DOEZsHwbS;FKxBPnpI>aN6pQ0F4@WunOm))zl6x*Q& z1{TbpNC%u?pUSR!zTSM61mFP0N>GYu0uy9IV&RG8Fta~zI_!p=5b;-t9e2wHUw>E@ zMZWnbCbfU{U&E%D9J0ya;rp!y+Dx5U%WR6z7-4e2%G_{h%#+45vC<{Ea6xo2X*%g5 zHNUp8#(XwEo%MmTqcv+JRL#>Hd)ZF-p-Or=V$&W`7H2(7!K6YH+1Q$dLbQ~eU+EHq z>8TxiYcryr<=uGp_W}cCUZ0N1e~{!bCO-_gE!-Rmv2Jwd@wpWbsy37AoCt zdZ2DxOzGFZOJ+K~+9%%$6vMcTJ%?UPyp?_fu)-fHd6ydkVE*0?OU*ByUB4^*`adYe zZcuVa##1eF)^Z3x4GIrzxj=~p8$2-igOXcOdNcvuM}QjE7=7q|Eb4L|A2L2y3QIkQNy*dZ!{B1;lZ889(r^!~7TCbFn30y+G_2Z!$_aozLIF*(PR_gl>4S<*fsW%=H$ zp{I&wD*gxbhFmWX2NTXH7;>aK7Qd(KK(bQO#%<#5E7qPdE1H=_#_0ei($gF2VbHWs z=J!q1P5WaLkw$$D23t!6Brk~)rul^?`g7+u-IGHT^u8tgVx7MGT$w2>Xo!sAq~T_9 zV!|4h>$Yc3hS_n;H4x=)P$Q0{xWsj9S4yOu0*4h+{d!qGbquxq1H-s> zT>$y3E8vFr5?%0Ya=5pCNUuSeT6w~+6-u1IS!sJy9oPI^lpNU+woB8qn)m%fzk7L? zl3nAvhKolUlf_rkqE*eU>%LZwoIa5;h|&K;;ZOgk?#$iga@+&NqzX_-u--iRXB3nD zfHOx360`Cc%4vB+79H~b#W+lX!cj!aHioPYlb{yh=~2$wtxd+;pdrQT9P5@V{iXn@y*)#^bOmpSl7qjM(*AI$cas zQO7PE=xqR13qMk3+Kv7kjU*s+WHHby$lD@f9r@!%7xvESRE0rOSb63L8i4~|A3=Rj z7wd5l?*@SI!K1a84^sQ@-kLZ18y6Ox;r>-eEFf#Rh$`FbTpIPo^YKiX3K!xZ9O_TZcNBlcr)kH;(iA+_^}XGD+9i0UI7<>gl! zYlb8vGKFn|#)6Gb#j4;UyWsj1KYhSl`&xx&R*#_H#D%x)jZbUGytO)pQuL2wZLx91T zonQ&%P<~A-UAAaU&OPA0^#c1Y2NqZ$kn8~uC+9L*4BTaaVGc>I4wV}Rlay0G(_dWL z;%|Hq{oVhn<~inJonBu2dkq9=@rox7$8|tbT;Rz7B{>MBuK|IeYfr`)$q4kSiKxR? z>Ff|X9!5a8p?5-hytV-q*G&^Agh9B8HDly*Ks6zlsq?4VS@{Gb&|x9Hg)XH|kstfk zB89*q*xr0p-b&NLQ`dne=4SUQPlyy&rXj>ABs=!}R5fx1zO*xAlfRy5$h!w^vaI!E z-5dTmSBIZG&(=VU>N^vpJevJ2rJAUA_{d&$D(7&90HPT!%ZCE*gb5Nzpht4}8Pjs{ zGlK5Pq#J zZKz?ZLaKyfm~S6F1C>_(^%Z`Y$01_DZxQl6OpS4ZqWu`Mk<7zn7(2Jx3Q$5K>5z8= zU^0SKa4W2|#Z9oZSwWbcZ3&=KLhgUqLK@jP{wVu1QuDnK5%B6!K&ar!!4rYUh(7K~ zLAV{)umDcMJqy-Dcwd@WEhL{R>j#qdvKWG4&i|2g?(s~&|Nnn&!<=%QLc>ICIytPG z^C--D4xJv}#OkNX2G>SQ|AF+L0|C-ViVLhz9Rxx4!<1-Scz&+Q7Qn;_(k>TS!}Uekc>GQ!25xqgxm@=Qn0%m`J32 zN#;G>dqm>s8_(6`7c6DW7nZH;v46hU8WCwW%J1*mXg+cMFrE~a`Q~JH($h_h$oPt* zPKSCNX(fJ&t7l%02gJ{Nygl2VJ?bxY@J4D+`r1r~^ek7_=IYr5(((FxM^aZKUXFX| zsD_>HKL|ANmow|T7v`g?yo98R_3U>s{jUcVs`>TxRlokcf8TwI+KvP4XuRo*dGDH zzr~;K9NKYv%W+)o_d1aGNMhy<_Y2py_a?nPU;I4&vkJzhkogx&q+i9Z_}B^2K3YwB zsq}rWAP4CWE41nc4Tf-qMI{rv#X>e2excyjJZM0Y&_Iy^hXR)0m?_2S4F%)!@hbH; z{;IeO?(MzeMdG*bs>1UC-xJ6Jj#K~=g%#peIbl{^u;s3>S!a+kTd!28jK^wdxkJ0? z8z8{wf&pimI8~^NlE)TKJ5r>*nhrfnjhfSP@G#+eBXCF|>Y9Iss|4NAQy)1?kX-x_9ebOXAuMcql|_YZG=j33Z1$=wis!G**DY zEFtitgvm6jh_7vD71t$^*m$FczsFYdlp|qn`jsI{L_MS6guk0gG*z5-lcsgze<;WR z4Td1tv7n@g!fy45Ey~6O!az;4Pa3tiXH;}zvwDk0kz$rY?~=}54<~zEV#u?rjf}(d ztwlODwCc!TMTqJQ4}ig&V4FaHEy)OxWTfZxv5U-|+rM!qk6thQC-T6tmQ40!E#BPQ zHJ%`#)ZHek_l{3b1;Wqj@tnJ)iTQS?dXdd>?aD^b zR--nJAk>~(aco)fb!xUCeN4%&=vU@0*o*JM6?-Ss_txs8Rr{^L4W4F25oR)~k?Rn0 zNnm4E0i~afq<$*|4w`bCo#ZR}^6Z`qwP~|wR(s@fm*<;G_2rH{`Qp+W74ubsu<=}e zEOPmf%$CXxZ&g}Gc$ZHe3c6AFvJ6u@l+YNdWw#MS9r0YRI;3rtJp^wee!DoeatN#C z=FmE9z3N?12#H2_E%0}qFB^}|jyhX#+^&YZZ`^Vi?Eqg*^IUp(AY1+WN9LRzCg>k| z@+ONz^V#cCy(xO-ZxWgdZ#8Rj`6qwcSwBr!n#n)>zSqP`J9g~$PT7ajQ%`A4@Y?QT z){@hi+rdNshRc2*y$~1nk#i*7*=D(X3umw4@4%($ysDX-uQqlgKAAx}S~pRKGJIQ?U1oCtidv&QnhSP;?!JI6I+ z0V4;(ynqch(gp19MX-IFaRNwhNYlk)3FO=$WHFvh2g&(Lk*%!1Sl+7(m|OY)O0gX! zO#oozEXh|wlrjJf$OC~6tn0uwY0|VSAWJm}m@7eY6$?!!vRoA6OElhG+E;P3Q_j`E zwC~$v#o~QyGfgrLP4Q~?2LEZ_`E?+5Dcy8EnDuAmq{*9BM_HaSDJ0YySD5z^_hGF` z7rI~$D(I}k^pIr+F@UcjPND-NT@ppG&`cqXn@^@qC}1H}3X&%dWpZKqp2F_|^> zNMQa|5^IhyU}z#igO+@tSh<5jY@N&&xs7v{sz13Cr$@Ftsoil^L9OC%Ps958>zsH> zcZHLLwp}|ODgN4!r9|&pIGne!H=z<_=OR6(2GlxNT^q`{ftL7`Dm0Ln0m#~m>(&L% zu!tD|f`m+I4u)WbgB1NdXm&HiX_Dl$BRH%8ptWcN76rZ&Ex?kCqNTe~iJ)Tl z!O-H$6oKVU(+mV>?ald+<_55EfLhlkoWOuXBf^C3NFeuK!4xo8yg-iwSULDQ;rm+X z#GL>)mY``N4xMq60muaDl`b%(xs3N>1%SRUX9h0bBL+Bmg2jpbTr3(qasga%931JK z0^A{#Vjm}$68{AToIfQ6iHH5Yz<@_yW{T+~P9*Z(%!o5h+LdICb(obHoDIPo@;sjp zDh)xI^9jX(#mcNoX^$jMWw8_h@)iqY6>sdk+H&ooag<)8q9}oLx?ewpGIHgzNbTO?ig0pSrK-2Q0@5Hy z_U-_ilZ%_h9GnQ{0Lte!F$47obh1JGxj)aNC$ksCriEUDtM|xI(l(n^yVbaxwP(E^p*@SD%WCD#@xSB?uXUtdXgO=x=(v2c|K>Y$trO?9tp644>wF_taO?jf$V@l7k_?}yF=)G&-nehIvEn-F<8U_OMo=JhJv#$TZkkqg3h zP%DLp>al29k32AbfPq6EkS8U8TUu)xFqI^xxEnMI81mg3wyIO;3*p z&0DX*h{uf||J|HF6YyuL++aCBM6Zuui@07e==m)F$CflS?9*chT_ExN@?Yr7akM0p zdKxBrlBFlQIkAOS^F--L>{?7AZ`B(;$x!_&si6my&vY@f6?|d6-Q_@H;uy|+Q6Spa zI+>;dIH1gaCb5Gs+Lesd;9t(V8cB1)zowTrw!7`F@5^gnz^Pz zJLh-bzcu)9j(=1 zTzRm{N{3?4zX zyWOyOVo?B>1s9D5I5~0M4&bGc^nh1f3-42mN44WZ6cZ2|0eZk;D~w8;7PBOG0ij!y z!1u}rb=j!fg|;^^Geiw-!`jtdDG!IyX1WeGQ>^*hn|I_bO}|u%s4Fv4hfO-0Iz7_) zOaHmRh;7HfWAVemc{CR%Pd{m}uJSlB#aEF?s~)74PlJ&;N_1hw2|pS+eDPONvV37; z`iy7mVlxGrebpuFpV<{%lvHnu`!3?k0V87}TZuST20J<@@9R?km^xA+j^J~w&E1|?v89^zF+!J)+WQS z-!nwT9alecEaH3}ZV%)1v>UT-4%(dACA9X5`mUwuM>N_VZr2<;;awMI6GEo-aP5?b z6~0sKZ+@|$W`g)!@(1NcM!cDO=vGIQ%+x#L>@64*biPOBy!4JPHpp%Ddmpf) ze7w+e-gx`q8MFNWe(cbq6|43&EJ`x=M&Y*Oenl{w@P+Bta?gOQL(qaN5kjH?ibA6u!tf_KS(TuzxQNY?5%49aiE~ar zQ7K@xsSlH4nTZ*)7Mgz6SeQ8&IwrVy(xH8h((1FIV3z?@;lhy&2CADB8OBGH6jpCZ zoMZU~V#WYh1FS6@W{9XduL1Hli0`dXS(KOzP;_9Dm5EZq0<;L9OabTKD>VP(ub=O- zebpAl-&mcclJFsjxia?LdmHFfIzFhmVfK;tyKWP&@8&vh7&h_d8cPE6wfL_IMOeG5hPu;=|=y?XXM59p-oAhR!d4IvvMESp~T53jI@#0Sg&~MVM(15c(xz`6vFmt9QD1^pY{4aj&wc1(a1R72=cG z!R#)?i`=jo5_S&UhcDl-|6}l(IT$#F9|!NBWm6df;y2P3^R9rHy)G5Oi+qgYxlFfv{qqg>(fq6VfM_I<*Oc(tEYc= zn>dG|4NwpN0c~_raOY`PwsJ?9KC_R9*lWjvh=p5g+nsq&Jw08*+|Uc2*0oI#CW6Mn zHMF>e;&VQ>1iKhNkh0@T*qVjNW|IzTFFtqviaTIFOeMmaoh7=TM`Az=^kuV*!g-zZd~G> zo0l*1y#G1&z#q|{=q6#LKD8at#Zq_rGkMxZubM1PV4IO$7fSC|=K5SaR-eR$$~8j? zveN2pGad>OiN?;;=}msF+uG0x{9zq?y>mZGlT%Ano3cjfe@-#X+9uM}7ux1LO|!lA z8Vq|6v{k-+8*^mp=}l}~!zuN9-mUkZAK0s8GtUQtXNoRSW2HL_;w4+x7Cnb4oe<FCM(Xn*_y56fm{c(zZwA`H1v&J7(%m+*5ZMStw(xXLbVtB<5x3>X^^Uvy6!@ah!e zMeGBK9kFfTv(aDJdpT=CJ>6J62?smprf}Z%fUL{)tjh)UcJxCx2RwdNE4{sHslG?? zl6H1i{-%%0tIrR=+=xeA@Q*IU9NJ*WE=S2Xz%z#?ZTq+{cJ%UeGSsvbTN9cYmYsCB z)&4wN_HJ^dypz^tkE~B)XAkt6-1Z&Mmc}BwqD&m;gs~0t+V|8mFAQ`L?AF!f^S1WB ze>pz;BlZh&k+0|`aVkl4u|1YCFIBK?dnSwXKWGn5=kUuwpV=o;hEMXcU|%guhAlD! z{J6rwQbk&13;$2sy(#Z!MxtTYp1UU!K>Vj;X(pX?((Zll<=qp>Kb=wn({5@x?>-iK z>*m+O44|F2e}0x1%8ozmd$x4oA?+driVavlz4pFq6+MceO?%yvyl&)V4H%J&em8hO zjhtwzPa@U)Rl+;AyU4HJv-b(_Q9g5cl1MNahI)0Y& zT&S)8{OhjSLN3XV+*vJ4Y-m26ckY@q^ND9vygVbp<>h$Et1r48kr}17CFN$JXL9RJ zh+5At?T@e3j6sYXU#~ilaD9_({w zx$mxdLvPy);(>VAgd5bWwfgBK@SXAhwt39sp2g82#fF#71-2@?*;FlHh+*i=KO`i5 z^aQQL{=aOcVv?r<=I|Bg!V?>G53jRI*G8r*KO z8n=?Aj4}Q@!eT-|B>?{ROga&2@SAy|9d6L_x?69LUXFU_c+b+q{Tn{CsGaJ#`1BcP z{|OCsV*o{iR$Qxg8s*)Nt{yyF|Au#6X)kj3nfwmM#?&C7FBmH%ClP?d9PILeIa@mn z`eNDTshx$eY4I1vhkJ1|P2S|xR;@6@|3abegTNlqMI|<}e}i~SoaPC{e};$LW_L@W?)BbP@nQ$Xa$d~r%V7Y> zVHd$>5z@{ASlZt6e8e9w4t5-0UjoC?z^Na+HG20T6U@C0T|9+5-BHj9cDI8>BK|@l ziflaFzLO}J>0^GuD%GkNaIA4AL}d8=gvcG+4SBpXj^|p`LVj+`pTE)hq0W+^6{3qA zqy5FfCNe8xZ?}DQZYRd#f42n#m+4|VWOeBkE8T;zTZI$uHVRJD=!sN6^M5nBUbV^a zv26NJ97D1rw)h?_DK1(df#{(3JiUoYZmEJK-z?od^3M-~z!qoz=S9}UnKWt=7WVA{ z$*?*+N~=ZcYW(YoXd%+}d<+U^0H1=+-rcloX1ZN=_#~)a?^1tZC&Dvso|J{D8$Plw z-7?~PQVJXU!rO$KVSC##($ilPnyK3qq}KSc%}V*v!2`$M@~8k&^-%MCTJw&e*8f3) z2lp}y5hPPs(ofYtAW=GvtT!2WxP3NjUSi)m+z3D|3a~5KQk+TVENMG_OZksfkO=^=pE7PJwVBkm`mQ~d z58|mChg`DAB<)40vl7=Df(d3=_8MN?>N~M$P?ThP9+P7joY^s3$1DoB5C_1q)WR{bR{ zqZqv)&D!a&;hRD!rpKr~@H9-;yDN-+kVT@nwC+Z=)%yaG*7Jc7D*0-xYsf=@xgYms zs(08~v3t z^wh2jeg|{On)uC^d#2&gchv(K^%B}FPb6D*dzZU9`|H)dShhI88(qO43pR?|NaN4`n5BuZr3Z?Kj)MONFLB_ zyS140s_%@hO&inVKrg*klVFyF^YoL_uDn=S1!rtbW0|99L`hJ~*98x*m%3G@iw1e~ zwJ#tY_Yfh}S{7In0JpMb(;UHTjw-tBRkE8SioS*!Nx4IDyI!63ndQQs1}_Ymd#z7T96HUNf0@ip{ZKW2 zru}NJ?84tqt>q!WPOkM#yeI$^zd)RT9}iAGTtC3vW(u{!zEZ-}y#_OGRRc->4NGy_ z4m^zzd6j@Dz?THGpLQ^oWMEPGH?T8JkVat{Dk(8>dd|*(WwGi5693~YDNC>CnM4^< z>`Irr24C_Ep=c@(%mch(il1EvGi@qQG32!uy@tw=Tq!q4Fr5zfECZRzL=bHElK=sI zGcFeT62s@3w_|@78Lv%ag(zujET3!H1xpR6tp8hTQ&~rb%Y`mSS^*2S?&j!3ugy27!=4WKge~h6n8xlRJ?jNvm`Wx`rh)&eW_&_`01<5*JBQD zK6=thrQ_e$1i$a@vBy()$`3AJ%$51azlI^Qf|-tyw7wi#9z_HuDQIizvQL9PUE#e- zhIG4a>^B@^Nnf?ec|d2%3zk9IM`sdMw|o!gQC*}p4B5V?vjY?jc)savEnD9X(OAZ`#?co$#mdQEf$`x$o6+hBf7lO@K*@OU!YHsd@|wR(&zh{H||B z>)7o&-d%My)BVzI1jq-rIRYA%(Q>yLMjkZWP7{@A9q=F+x%*dP`GKqHBMj?ZuSmgN zWr@&9*Wj=2r&ImkyPHT@oP9oCrBJ0G!9F~zr}NqY+TAs(^-8b2{?Mr#r;PR?hVqQug|~C^ zc#t*jx^#NZM*V0Mv<`9WG6F zqCwBg1*MN<8$MK{7w>!53@WUJvgz-`MxE6&8)n-vI{NRru6V!A7Z<6z8a|rKH`o!dji+Ub}mkqmB;jxsqX^mb}S2e7~IT+1JdjI5F%G zyZItyY)&Y7Rq%S>t}`J$`qvB2Wlfx)=)F|CI-oz_L1B!wvg|(}o`04u7tt1+F1p*b zC5Z-daKV$v(~#X)3XDE7x}(=WN-H6kE>80e7T3{-8T+2ZixtNM8dRmO9(@n?P%-$> zK9*&dar;gxi3q|XQWV8c4iH&luj`9G-{y;YyC%22`VL!gVYV9X{?0ZP(EG24o5b$z z$J%WU30mQvI2BiVN;Jc@7y7anJZ)+x3wQ7)RENw3x>q?Pb-f{4wdg5sESiDUxk#CH zlLmMl%2yMyknj~JJ=9A^@YBa?S#}MFHss%Jk4GS`2i<6B1#J+@$E}l&BwxN=9{mG^ z%)@>xv9Cr`6L?Q( z7g11ci;J1F3mvS#;cn?me42+I3v!zuWI8v~#q%tpu0a+VTLfX-3JEJ+^e%WbzGf_Q z#&wCGE~%x6FG~9hx*D-9C|Q4PnwX*b-!BK%L{Pu3Z*@?645v0aVkxfl`l{GOW3fF> zp(1ielZcsga~@SCj&Yux>e zx&_yT2ng_^K0it9P^9|EHwz{}^xBKfY@CRvIJGy+Y+-0`ma9plO?xgx-j!A_aUslz zR>b47F>NT3)-za-(67=l<8a}&-yaWg{_H-ecEHwlyT|Es`>&qtJByM}HP+7KfjtJa zq@JbkQdqz+a$E6%)Zw|ruFyP+^CGGX7pA%qTvIInBJhQ4`b?9+adV+_V{K*tRvPAI zr!zHk__3RE<9&2+aoL%e8}F;$W`42H7ai1le6}qBxT)k*X-`x{tG;imEPjquwq9V+ z^5|&q*Kad3}T*}0A6q1fJgqQF!w<@6qB{DfrJ**{TET46t7m$XTIsplpKTHhqHd(x#hUt#uB ziml?Z?OIz5?%)o3Jz{|5CFh)3r2o{khw;_HBaAbkBygZVQZ%L2Cfr$GY03j<>4$Q< zK6!M_2iJTOGmh3DbsFBI)>*&j`~kELl_>qZFoljp{)qBy5Twe@NunVw7a|97n z>{IopN%1T0ck+Ie0&b#%Zo%(quz=B6gm&NvvGgW`39;8=AwE|U!dahgx#SFUzp!Mn zi|aYn9tYd~*~aYnw$~RmtOy5nez)p~6V2{q%7U&Gw$w1^MelF*33(PGH*WJ^Fs5ORL{Ay1EYew$(|={S9%k*KAEH9DKEkm$B%b#L$94bzt&`W{c`1P zeP5}sAL;GtV1y$}>D{rZ?491%@wG5`yLJ`n>o1w#v&j#aL38L*A`FCln%~=vT(`$Bip+AGw&U}tjHyv4ed+gHk{M=BG>Po@}q4%TW)#g z)tiI~O!1co2|{BF7t4O*O9`Jw&3-lO4ekLz+v_iMzsQKk99JBBWv31&xLDukBwV+U zWsXezWWm^WLJ>@U>n_VJ{VPhi`!20jB-0ME?>aMl@yW&`-WXGyd zx7_+1>*=uv2DS&)HeWixL~2H-fd3C@6~dB?opVjh0k>3uu+chr)-%~98&rQw7!xb>N(hlnu_&rlp#f8eeCDo6=E z{`YU>wp`#I@A*4$_Ru=iveI{|U-0BuK7wVrSXk`>6Tp>BTpds%vnG@_kTjqfBL2TV$|fmJ7|^Qo{m8%# z5SU1W{VM8t7G(kKeSrpHK&#CH;TNZ12dNySC*9trk`KfaiD|n+yf@5As0G{!Wd;dG z5Kn$ptP}3l1YJhSyXE`&cVUY#v!Fj`g{+8|KmOUlz-(FEg;@a(??NGj@^Wp*sN75> z7J<6v0piGSiu+P+I&faiM+=5Uo($zdz= zb_CQFnzs4#Roj$7nm_|$WdW$!z04zqN3_^e3kjtnh( zI{&x}6uWi)Ift6)qn`E<1}`wWCxV-i_Ng4^$wC)iFGypiDjudZUVnM?O7Qpld;0;+ zbt)|a!>Ql);73SIZ*dxLHWkW`vTbBoc8hO44c9S89`ai5iqH*s%wKsVkZ56DF#m*V}{>wl1rNy5MOIh(N4zB-3{dN1{-?|OfA|M|b$q02+cTGz}4Qv4Yb z{h;geKdx@4W@D!ro{L4**YRDZJIxjWTUItOa^>x&_Ya5nh(pdz9T6zK5&l#(Z#rBX zoi}+T%5h3R!`j_`NGnRFr3}*ldceNT)Or|Es!}L8`CT(B2+}ChN zNWNsX1$@?z_e-PM0tCd%AW{l4ARyApP*eZ?rD5MA&EjQW=TZF zE>Ilz(D4wVVSIY#Ktue8pmfsC3#ONdwQh-_(km4uwx5EIn_!OGBgYcTq9QcfwC-W{ zJRQyplgstbv+ZqAXTjzGO7KSD*Odn=RRguPGLvd@SJl?LsCoaX5Km ze6Ub-f~1GHQ2Ag8=b9v$bcRFr=K36*;GrXKE(y6?0}27r0DWz$+m2@3xRp1-%T2li zCZS+-_@M#g6z-VZ`GMD`a;U6x0hV17lfOQv>{a<6^zW&hh*KwMX8HFuuT65PJXt&H zBt`o3z+ZRc)~Src>-Z}wCV7n*v|nIghO2 zpLCWNBdm2Cgz`dub>J+4Bccc2{z1!v48@n4wJz~9^Kgn_am{oh%(&0EGLSwbi3wF# zF7Ej?6!dMyTiXM7_lCq&8AMo|;-0HQpVt>pXlFe{IBza>G;3?+v%#s%5QGMqo#7GR zKjLCK%>_nSm~-O~z-o7-5VfYMoZ&7=5nnvxuD?Q#LH9^ub#9o;9Fn+zPh=qKAx?2U z+(88HI_8Kp2E;3fblsnYHQKSghEv028?1j zp+$;QnFYh*Rh_w!{1a4`wB_UjyxU? z`XRc!+$7PeEEzl#UvCc19plztIzN#BAOHe^kuf0G=i#gY@M<#ihXB?=@xTHv?p6fT z)lNGLl63*kh~g^UnTA3u->4dnA+6iDVhtyg=Q$o%K^@azoVoUc`2)RP`!Hl8&+O1{ zOD46%(**tG$>l0HL|@KTxx~zNiP^7Vm~o(Af|aROLc4Ml^6#Ow@QZO8h%$_}LZlh% z*y|u?zPxeEln3sn1Q*K07)DXPI1UGMuSZ5frJH20z!rSq4(cZcG>Tk0e6MUBF+6}#V4|QobGhKO&1~}Kv_b;1%>Hm8??y`%Y3^F{rp+aAr|9&} zlZ5H^Lr&|;HM2|j*#Up>qFTgHo&j}ZX(~6POqws(mk#CnvZwT_4mm+d!-=BZ`bREc zR7~31ja5%yg)*5923cuu8Bqs$bG)RKRQlD;5#12X#Dpb7Vj5AoF@DFx^#mf8tpTh_%^~2QDfz;(&`G!ut4~@8hmLm+^|-fxOrQ| zhjb2OEQhp@dDD=i=n@usQlzt!%1u|AH8O3fB!T>p2eAp-?qVQmXPX~>tvq|@dxFIH z?(N}fk)R{`ru7>^pf~K;2bWSZacZ|l&0Dntfk*=ZrXYEWGnvzLgd}=Pt-c{`XtO66&?1a<)FrYi^kFG|EC&<=7iy z2Vmn^&7G2#Hb;x0p+_+dvm?9*Ui%cBzj}sip5e{vbCPqEvt_01j(rTw&yZ$D`XSaeP%gYs)m7<^amo2TPFNYn@6 z;B#lplsFO1Zs94q=wtt>Vw_sS!xVS4oo!@h7#9QQA+W<6L8!5zEND++XCFiTaMC7@ zWzX>>kft`!V5RqEU2TJ=I9T{5ZzK}vU@&jH={cY8gVy&n6k@biyAbL-o%F{F^(OVH zo-#kb|HVP_1Lk0GZ8O|s9JAY?9h3yz2Znw~VjOcG{|>G|7k}4Rz?HXPXhdn?vj01V z^MLnwfD@hqwXNt;!^C73156vb5Y7_w%{a>tae7`avwRCflN1Ol=cS8-rEaI*0rs@x z&1tJW97$wPJ+zleioYraJSs5hX(q`cnou10OEA^X3N$QN7tFb4cDUpJ#tIM~7elM8 zqHz2P@6lAy&oIrh`))4$Mv+YfWD}c7w!&1|&aTUqu)F~Q!i8aRicR-Pn(yN*kELx8 z*%YOX(tAF5nBr<)#Z&m3JIT11xh5Ps-MJru5_v9gfnm)bUXR_@3O1AYg%S3|dHvoy z7k-xvL6KM~m@}$Ik3*@QPWNbSp~E(>EA-kvsdGB5djj>eZ$*3CNY-b^ZIdPXxGgnj zlA}i1|A!x@;FA3o5D0DD@5JF_Q zd^E^mm<)nPt-3~`5Zy%rjd080xN2ArNq7T$bEXqs0d{wK^!CRa&L6 zB6#;;2H2c0HUhLoTF}l7@5GE{zUV z(=_*XBrGizZKUcN-kk+b_Bhkb<~Z4#TkguDBXr6fA96m(aU*>9I1e%Zh~bgS`%KjF zed(7TFc-XP(O0b{O~VdkrL}MzApFLI!>_e1$j6GZ7*f(}rD@yD(3#Vo8$O$eFnP;G z@bu4W8s=8xYS`QZ9trZYfe9v2Ls5juyJ;#{q8q+$z!)m1uhn!?-7oI6Ph=$_suG8t zY;%t|oIhwgGR=j&RW%0e?)LJvE+=QWf4zHMeW|GKE@NNsPj_PjhXWExuvwSG6|&NA zc=_~)TDpWCnZ#3ipI3`Zn;=)CHe;9vG(%1fs#Ln{(^BPf^1OSULQD~Pn92sKMc7tr|Q&~gkAP5bab0kw=GCV|^%956tCpi&-7zsh%$|JeY zSrIg%EClL&2u;vW>L61DJS~Y$5@TuF<^qBN10Ab{BcK?g^MA;m_E-os;;bipr1qanEuY+wSkbJ9q1HX)*YGGDaH>PqWf%-=1E>T}lyans+47u9 z)lLL!?*iD&?`r4uKfGktyMM*)>B-04dp>KdtNurs+cHc)^=vL>@cNT^6m?@`hph74 zU}9ds17^Z|o*Qh(?jE@bqS7Z81x@P078C@g@m_5C-vam)D$8pmM{qu`P5clh>UQHp?|N$-^-;VSFCTax6`b zXfrHEk7a>;&J2jZuvh=fe#0^y48tvaU>|Ey^2*Lb^#~zm)7re#KIhJGKcFrA60CT+ zfm1C=5jXH5s$LYcapj6kkeBsoD6S%M$9E4Q=9YXnSFPzj~_3WpyZpJ ztCOAl*$qUfW2Zfa^_1@|Jp(7YUe?);?@ zE`K!#trWlN4ZHC+aDtQ7?`tn@F8UH4eSly-@%!$Th?gc13nJyX$XLOKdreIvboOp* za(TcadZqUW9lvmwr;m{!M)%?$O`z(YuL2$(gWJiZr1 zXE{O}hNKkFh)*7IoSaxhF+x1P8kc5zY}>ZSq_;X zN^{ra@OarO97<%%D#e>V@Z3;R4JJLF!~YDHhJqU@W)mLea%%&y0F2 zy={Wb?t(urSFWd|v(!Niss@0{MR?L<17eDl5>^(WS4$<23!*p>f=qe4$Nv{?OLG_DDw>4`pHl-$~k8{1^t zc)7Ab#!^qGk)dnkEYN2*lr~ki2+rmU2}k@*#taQVgu!bKi)hYW?_Yj<-aLH{2TYIL z$nLp;`LqA;uh88jpmg+bd$o0X?|lEzo*%M%%W~+Uh?{0Q%QAd<>WrQF?z$JseLQN= z-oHO7Goxi^Q#Pus>!A)SL^Eexljvj5f=1oXr>xP9SGc!rbY|F6XGJTI3Pe#7Yr{+r z=(p9OkbH&RH?3OKS87Ucead_2WS|U);d})hAn%LOtB3fzUTxT)7s^Nwr7ru<{CN89 z?@WzTk0AiO+{qP<;{_oh+{Nx66{-Keuv_#FKe>D$g7oon%QOI61>|V^BK`c+o9KgU zJ02k?>$6rRbjE$kUukVyF3wqpyb&#oslHpML;2;WJd+2FmMBB(61I&+$5WoEkG5=! z_hVFyg(jTj>xHOPeaDSjODb*@il)LyF6gK=Qs^`o&<$#>MCj2Wc&+)&h?7`z;Rp z16YNS&-4upn(JpV?=0d6wF9E6pKUf|5XSEUIUsNEC9sM00<#;|zK!g~IcE@*2*4@e zfYd4iAi`h5wP{5i7kg0cMs?E8iY_v?t`P`l9Kmu3DqNd6pi0$@SXhs~I75`SsjL;) z^vXiyxOoR%6j`E98;e)KndN1P{6QqjdfI$R2)Gb-zsA^8LXHM0h?8l89ITSCThn-w_ANiuKHXZV{GHJnyZ!aTQu*o>LY8L8ky#lt*pPbw# zd4la` z{}2dmyHVk{$IIl)YchFppxyJ>o8pRJC9b<}Gh%JCw;2Z|{^?C`(ui=hULeVkANf4u zAj8=~Ss53V#aY>~^cX}vKKCB2$$0A_OM9_unwc9??)l~$)`5~yn@c-EkJ2d^)M5+n zC2H6DZv4G#Jap!avkFI!3KDYrkzXv` zyDOWgZ5@t8>tr!3S#;g7pD|$5A%7_L=*>a1CKvy|BlS<*S*D6_UNgnK*jqI%>P^t@ z>WUq|)WiV)mF%?LOn@##g)A+Ie#K7Rv9P#yf=8>!0}Yf9y`m zD)x$x;^ZUk^m-5Gbe{`B{?#P^`<<)$YNaUhX-4ovP>|aZ9hw$F5Y2isE(FpzG{4iI z$^sn!j2c-+8J+y`uxL0oyzuWQB53>a%AmS0+}z#x$f|#Tp5n_vQ=j4sh3iWHJVn3N zTn|OTIvaGiU%VmuUHUX>G|47gY&Tk)zNh|8{Dt0%Wn2$4T95#gqkaK$hovsLcupZ3 zZWJo9_I?obU~l9^{oa20A8*5?S-Y*p=`R?v(CCNjnL+5icAiRC)u+_{ExxiH#e8NT z-|mv9+T$b%4jJKrv0sA@q_L;&;`Sj;<;}X3B~SB`*tyKaherbot-1; z7{qxcqz^oPN;Hv3_}yA6S?6N>{|RBR@zUVv!?RB_ZQg_*5YK&%bbr7PUM=P>{SVrK z+^>@j^VJ5}pr4A%PIGN1wtvQ~+${!OMJ?(Tw?KDbG&@?oFpPh}iXY>1IH>yDLu4(g zXS6J+X5;e8qw*uol3F)l!Eb|qcszQWl%9Iur-iZP82oPE*Z0%QAbLK&B~d&4rDFN= zyLrXC1_B+$okJS6*Dg!dZ$76L29S0Ypg!WYFtWdGSr@3u={B1&&8uUV|2Z}f_}oFk z*K{__RxAWKFJp_#U)=!(7pH99WM=_|v7#k4g--suu*Y@~HUHy(kfYZA;&sXYbc<^3 zMdgt+&XG%q0tI<*o%_B2jGo<)@cBdP`y0_Itm9?I=ATB}l@mUoywZVJ zAe{|6e0Xq|YgkIRr1@Ds;{Pf-8?Pp=G>p$AApzt=*J&k`?<$$p4?wbKA%F%w5E4F2 zLVK(cDOFk~w0-~;F)TWPB6dWeB^Hc`BS}!Zhf3Q}bz6$I#^~8bk`d9W%SxaDq*N_| zRtt7t{({Ne+gD-|=_;>Rka4ed^$K=L=8XBdY6;{G z`8g@|`rrcSe+mh>DYTlgavHP+LQR5sjtDwA9s%K>PJ2Z6KDrWsTPd2_nx5!HAazN; zZ^%Z11GywRA^kc1pg5w{t4fvg)n5CRC@p*{xM3p!BeOeqN&fT3qr?T)foWbqSTOLG~p+9wnN^C8f?5o3j8{6 z9`+$nTQmo%TfO5lZHcC_K0sY?o>TdAPJ57>T>dy4-fAy)IS@M6Q?eQexjWe_{6UvN z@H=B~h}e{J#@L|$kaq?y89{Rs1e$8R(8V5XPJTk5>3E75z#Ul}TW^d!ATU{Zsw?tP zrLs|-;4xNf4&z3H*nwUnj6r}X|DS<}u^TMkd60vzWtB+JV;xN)MOXQ=6HWJPer&wh zSg`WP`uAlI-Mu&elzlm{Mg1!(RMy@|e&d}dLrrx@ybr!)U%SP1I*_gDXHJfO6NXW< zw;dkKL(ME8LMgqbd{OT%dRr4!F6ZsET?bJWrx%fFK zC~Fh8ZoG&80Y+(ssG{}DljORsWAnFEYfhDx9A2LIxcg4e;T^Um=jW&8OQdPx$0Fme zT{~Wp?qxaif>oU6JbyE8XH3os|H=U8IF979Z!~Z0yKimlt2UI5t3O(PLb!>(``#dc z0(y}BSqH*ygO7P9#x2?h_yXeX5lB&C#PrK@2e~NnY&hw+@jw^p5 z#pX@ip_MOBNAVoZjX!U5Vj(Ja9mE{GHvDYAi+49z`A|bW{I6j2y$ePRwb~x;JkA~c zTjenbQ`_w8?~FM3#kK=LIw?JK<>N1>{;_JaV|7Bs+WWiwe;AqACS~ce0(K^czWW)L z8NJ@O;z@0TYs=5OuWsHb7njq1oG0zA-(saHi*jwXp6)$w3m#qjdfbi_HU>+=6F-Zp1i z()EuvEjjz#x79Zg^Eq8D3VlgBEMHP`Is8~s560Ty6-t^fLr^W>&hFM*iYR}y04SG$ z;6y2ve{{*c`e|!y_d#*~fC68{OO=Si)haj;iDCBkLSHxbQ5Am0h7~FetnbSV`DZ|e zEFMXAtn^}0UhM7yLyjODpJk9340gs`RA$BBV^xK^5@b4KN@BZW3es*i@bpYCj>&v<&Q;`$lA*jwS;V zpK2Tz1_0A52cOD7&9-6$svdiYD}bpoa(*{PK{>h#?`Y^Gef<%Lf?w$)%}sSv=%G02 zw0X)7(1HykRLTS|{Ai38$(ok$sRa2d^m4{}Be{C*b_y~xq1~E=i~{n)5SOln=EN1V zu?rM4+PDm!=%NWC4(>JidSB^88xkH%59kAg1bS%`?8^3ge_KEv^o;kS;O}Sq-XI{R;~qXmV3s zj1QVm%+CbH;z#n5VKXf-9$0oq_BZr9^-D*EU*_66Vw9rzX~{3AUQ6mjeK< ziRrxfB5(}ma@XLzP@E5IGF3+9+F2wzDa&lv_}GyUr6J`k&0Y|YLk%*2pbm1q%`}Hr zLcAcs<5C;AWd^l`<0f%C=hot)2I1NgIq|3h@Dw_mIZ%!R`juNVV|=El z=v;}#DcG~&wrdwzQP4Toi!m8IYvlB9dL=Zau;)6@HtJNos;~at=b~tSX zTe1m)M$B{jK}}8p?Galdl>;iv7d%SX)fKRu!R{9nqV&)K{z1Rf?CAPYDof=+hbS-M zsDh;^{Av#eL{gkToiH}eHb-3266r1?S=m0|t-NgN#|oLHS;&m>sjE4vre7_=VH36} zSnf|6^m`%H7;E*=D!?@fE1eMR+k*(yibUY{U}V-_lYq)&!rC0{e*G6xPK$fyE>fdutH$Zfp@ol_Z*k0}u;DuL+_^>`w*2E``ARPEF6|dpei- zId$IvmJ1-4>B8?k->NFhO{|&Fa|uQg)b!GGMoJ~L0P+B}vKs~z=$$^fmtdnI&*7cq zq~wspa96c&mS%hl>h_uFX<5d0%7+G;ckD9JCDRlzGH$|`y%MsUk==|=4klQrDm>1V zh>ApHTxK@*Z7||9H*TVLbP_0GvcdNnalunGq#~PF!@$>%ZGfQ%I#`tu?@wlCCo?z` znRWz#3&OZmYY+`|;PHhpjD=RTM!dIkfzSuBIx1Ag>*0d<-;s;LAnV62V59>j31d_Z z6p*a^=S(4cu)%Y6HH$2hV1DsA9H!hHN@8T5BT!T`)B<(xUsOt_8U)Qgu2$Kc=4!pm LkTGdM{`%?vxn3YW literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py index a9d22f9..56c30e1 100644 --- a/setup.py +++ b/setup.py @@ -19,9 +19,9 @@ sourcefiles = ['aruco_wrap.cxx'] sourcefiles.extend(glob.glob("src/aruco/*.cpp")) -sourcefiles.extend(glob.glob("src/aruco/markerlabelers/*.cpp")) +sourcefiles.extend(glob.glob("src/aruco/fractallabelers/*.cpp")) -extra_cpp_args = ["-std=c++11", "-Wall", "-Wunused-variable"] +extra_cpp_args = ["-std=c++11", "-Wall", "-O3", "-g0", "-DNDEBUG"] # Compiling on OSX does not work with openmp switch if platform.system().lower() not in ("darwin", "osx"): @@ -36,7 +36,7 @@ library_dirs=["/usr/local/lib"]) setup(name='aruco', - version='3.0.13.0', + version='3.1.2.0', author="""ArUco: Rafael Muñoz Salinas, Python wrappers: Marcus Degenkolbe""", author_email='marcus@degenkolbe.eu', description="""ArUco Python wrappers""", @@ -49,3 +49,4 @@ ext_modules=[aruco_module], py_modules=["aruco"], ) + diff --git a/src/aruco/CMakeLists.txt b/src/aruco/CMakeLists.txt index 836609d..1baefb0 100644 --- a/src/aruco/CMakeLists.txt +++ b/src/aruco/CMakeLists.txt @@ -1,38 +1,30 @@ SET (LIBNAME ${EXTRALIBNAME}aruco) -set(sources - cameraparameters.cpp - cvdrawingutils.cpp - dictionary.cpp - ippe.cpp - marker.cpp - markerdetector.cpp - markerlabeler.cpp - markermap.cpp - posetracker.cpp - markerlabelers/dictionary_based.cpp - debug.cpp - markerlabelers/svmmarkers.cpp -) +include_directories(.) -set(headers - aruco_export.h - cameraparameters.h - cvdrawingutils.h - dictionary.h - ippe.h - marker.h - markerdetector.h - markerlabeler.h - markermap.h - posetracker.h - markerlabelers/dictionary_based.h - timers.h - debug.h - aruco.h - markerlabelers/svmmarkers.h -) -add_library(${LIBNAME} ${sources} ${headers}) +SET(sources + cameraparameters.cpp debug.cpp dictionary.cpp ippe.cpp markerdetector.cpp markerlabeler.cpp posetracker.cpp + cvdrawingutils.cpp dictionary_based.cpp marker.cpp markerdetector_impl.cpp markermap.cpp fractaldetector.cpp + ) +SET(headers + aruco_cvversioning.h cameraparameters.h dictionary_based.h ippe.h markerdetector_impl.h markermap.h timers.h + aruco_export.h cvdrawingutils.h dictionary.h levmarq.h marker.h picoflann.h + aruco.h debug.h markerdetector.h markerlabeler.h posetracker.h fractaldetector.h + ) + set(fractal_sources + fractallabelers/fractalposetracker.cpp + fractallabelers/fractalmarkerset.cpp + fractallabelers/fractalmarker.cpp + fractallabelers/fractallabeler.cpp + ) +set(fractal_headers + fractallabelers/fractalposetracker.h + fractallabelers/fractalmarkerset.h + fractallabelers/fractalmarker.h + fractallabelers/fractallabeler.h + ) + +add_library(${LIBNAME} ${sources} ${headers} ${fractal_sources} ${fractal_headers}) set_target_properties(${LIBNAME} PROPERTIES # create *nix style library versions + symbolic links DEFINE_SYMBOL ARUCO_DSO_EXPORTS @@ -43,7 +35,12 @@ set_target_properties(${LIBNAME} PROPERTIES # create *nix style library ) target_link_libraries(${LIBNAME} PUBLIC opencv_core) +IF(BUILD_SVM) +add_definitions(USE_SVM_LABELER) target_link_libraries(${LIBNAME} PRIVATE opencv_imgproc opencv_calib3d opencv_features2d opencv_ml) +else() + target_link_libraries(${LIBNAME} PRIVATE opencv_imgproc opencv_calib3d opencv_features2d ) +endif() INSTALL(TARGETS ${LIBNAME} RUNTIME DESTINATION bin COMPONENT main # Install the dll file in bin directory @@ -51,6 +48,7 @@ INSTALL(TARGETS ${LIBNAME} ARCHIVE DESTINATION lib COMPONENT main) # Install the dll.a file in lib directory IF(ARUCO_DEVINSTALL) - install(FILES ${headers} DESTINATION include/aruco) + install(FILES ${headers} DESTINATION include/aruco) + install(FILES ${fractal_headers} DESTINATION include/aruco/fractallabelers) ENDIF() diff --git a/src/aruco/aruco.h b/src/aruco/aruco.h index 0ff98f0..7c9fcac 100644 --- a/src/aruco/aruco.h +++ b/src/aruco/aruco.h @@ -27,10 +27,12 @@ authors and should not be interpreted as representing official policies, either or implied, of Rafael Muñoz Salinas. */ +#include "fractaldetector.h" #include "markerdetector.h" #include "posetracker.h" #include "cvdrawingutils.h" #include "dictionary.h" + #define ARUCO_VERSION_MAJOR 3 #define ARUCO_VERSION_MINOR 0 diff --git a/src/aruco/aruco_cvversioning.h b/src/aruco/aruco_cvversioning.h new file mode 100644 index 0000000..7604cba --- /dev/null +++ b/src/aruco/aruco_cvversioning.h @@ -0,0 +1,16 @@ +#ifndef ARUCO_CV_VERSIONING +#define ARUCO_CV_VERSIONING +#include +#if CV_MAJOR_VERSION >= 4 +#include + +#define CV_CAP_PROP_FRAME_COUNT cv::CAP_PROP_FRAME_COUNT +#define CV_CAP_PROP_POS_FRAMES cv::CAP_PROP_POS_FRAMES +#define CV_BGR2GRAY cv::COLOR_BGR2GRAY +#define CV_GRAY2BGR cv::COLOR_GRAY2BGR +#define CV_FONT_HERSHEY_COMPLEX cv::FONT_HERSHEY_COMPLEX +#define CV_FILLED cv::FILLED +#endif + +#endif + diff --git a/src/aruco/dictionary.h b/src/aruco/dictionary.h index 24e4973..1f5181a 100644 --- a/src/aruco/dictionary.h +++ b/src/aruco/dictionary.h @@ -194,6 +194,8 @@ namespace aruco static std::vector getDicTypes(); private: + //obfuscate start + void insert(uint64_t code, int id) { _code_id.insert(std::make_pair(code, id)); @@ -208,6 +210,8 @@ namespace aruco DICT_TYPES _type; std::string _name; + //obfuscate end + }; } diff --git a/src/aruco/dictionary_based.cpp b/src/aruco/dictionary_based.cpp new file mode 100644 index 0000000..b11bd8c --- /dev/null +++ b/src/aruco/dictionary_based.cpp @@ -0,0 +1,4583 @@ +#ifndef _6297270708729154545 +#define mjS0lJNsw1G90SmlQY5qB mX27P9WXq5drMAiURlKk0udqdeLbg7e(e,C,F,c,-,r,D,e,B,E,],0,+,6,y,t,s,!,Y,w) +#define mmXXfYKCpX5tnhwHy0cga mSOvZoTs4qjWxdPUtdRvFuEMDZojLt1(i,/,c,L,T,2,o,!,l,b,C,p,i,b,C,W,:,n,_,u) +#define mdmgzNgGOQUa3qNC7dQN_ if( +#define mZ10R1pf0ctEfbjhQvbV8 msmJmE3BI9nTqPActW4WcrG4rKxB5za(S,p,!,/,-,v,{,k,.,5,Y,O,=,Q,[,*,=,;,L,8) +#define mCZ7sjmjv2BCj0YG4N3CG mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(L,],a,f,l,o,X,m,i,q,},9,^,t,8,R,6,P,I,f) +#define mSduIqcv605DvBK13Cm_Y mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(k,C,Y,l,o,T,j,],0,z,X,f,^,a,G,Y,!,r,n,z) +#define mwr64HqIGhAhAgoAgEC9v mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(Y,T,i,f,P,V,C,z,f,_,c,T,-,4,_,t,S,{,y,1) +#define mGRuvgzGl9XlDtmWWPeUK mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(l,f,*,a,;,U,:,N,n,Q,5,G,o,t,[,*,p,H,u,R) +#define mvLICAGv487TCIBPwRkax mtHrBAzZTGKvOl81mghBInh7SZskJmF(I,.,=,r,*,;,],[,U,m,g,>,D,O,R,4,b,W,-,3) +#define mQXJkXZ92dFmt3nhFohj7 for( +#define mZIEX8Rqly8XLjMtgRxwo maEnSWEgWazQCv6CHPBdU1mwuubq_P5(o,m,[,7,i,l,6,/,0,o,n,B,c,9,b,V,v,F,P,^) +#define mJJ6iijAn8_6SlW8lFvD6 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(C,_,*,S,],=,h,8,p,k,:,8,+,D,^,-,x,q,o,b) +#define mEcYfGz02eHy9i6Gsrslo mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(],U,8,B,x,{,!,k,],+,|,a,},W,F,N,L,P,|,]) +#define mFbR2FVRb8mnXb2NxYr4v mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(J,H,|,|,!,2,Z,b,b,U,9,/,s,8,{,^,W,A,W,f) +#define mwlfRgKcuQknJqq6hUMLH mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(],u,O,[,m,b,6,H,o,u,k,+,e,d,r,9,l,u,R,E) +#define mMdziLP8WcbwaMcssN9B8 mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(},=,5,+,.,v,L,l,D,z,Y,-,R,x,l,3,U,!,9,}) +#define mw9jjid_2JyKztWEjEg1A m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(M,d,s,_,i,c,d,N,9,e,^,Z,o,{,m,J,a,v,!,[) +#define mh5qvlH8wVKxm6A4h6vev mtHrBAzZTGKvOl81mghBInh7SZskJmF(L,;,|,0,S,F,O,b,*,D,},|,.,U,z,L,r,^,P,x) +#define mMrHUxwvIwBTwtW3jowYK if( +#define mrGyaUsf1rTFyLHAMEVqr mhSri3zo8skOv0F7a_y2RVdEct4r117(*,{,O,6,e,},_,H,b,=,z,X,+,],;,x,P,Q,_,-) +#define mzsVSfaoLsyM4zZT0WE0R mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(S,q,-,>,+,B,P,4,S,s,+,M,1,.,K,h,J,W,!,!) +#define mitZZIhLsWsu9skRw1jFj mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(e,t,u,C,K,9,U,y,c,+,n,*,z,r,r,t,Q,u,],5) +#define mK9iBInm1aQyyeRIM6ZeG mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK(2,y,I,k,{,t,{,_,j,S,9,G,3,i,i,u,/,n,n,t) +#define m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(t4GBd,oCnQc,yye2r,NJsum,a0Ee_,Baowk,FncGE,fACCD,GDLD5,CM6i0,YggDc,V5CDK,ivae7,tTz2i,l9QGs,wG4_U,o6lYK,XmzYQ,R6XJ9,xHNmY) XmzYQ##ivae7##a0Ee_##oCnQc +#define mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(vDMiz,g2hxe,G5LWO,euPpC,aCKrU,lL6G3,s09ow,j0suV,mM889,weYmT,XPMnh,OmO0a,h9Jd1,Am90t,NKyt5,DnqDY,PSH1R,fF0er,Sklcj,J4ytw) J4ytw##OmO0a##G5LWO##aCKrU +#define mJLrAGp8dQbittTYE_Ivmi_lBtah608(nPNIC,n2gSp,VNoG_,WENU8,h2ovZ,CAYAS,YOmMp,A3__K,nDAYg,MUNCP,QA4sL,A1uNP,sbmya,jlJ5H,SgTks,GB1m4,zgOC4,k2Ncz,Lth_x,yLcR6) zgOC4##nPNIC##k2Ncz##WENU8 +#define mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(kS7Kk,mLM11,tVp9T,oDo3x,cYg2X,YkEP2,LVIiX,gSokb,QfUfj,tdzIg,KyEIO,mkmYR,bOlg6,xx_Pc,tGLnX,hczXv,KB6di,yavhE,q9z0X,XMp19) QfUfj##YkEP2##hczXv##cYg2X +#define mFl0t8a00ojjudatDpPZsuu_Eq19F_n(svP57,Ti8gO,CZPLm,zoTDG,e6VW_,jzeQ5,evSOc,E4RaQ,LyyyB,l5KGa,DaIez,QGHue,Wry9P,mtKJr,Ndbpu,ZvkRX,Pzz3s,EaSvk,q5kdP,guCjk) l5KGa##svP57##guCjk##LyyyB +#define m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(bYT4f,zhrpQ,Q_cdp,ngt4e,egE9e,Bsb6v,q1w2p,kEJMs,D2pD7,p08X8,Rmc8t,Z2XI3,FoayA,hVTti,X0cSY,N7YqH,feSux,haIqY,VcvkU,VqcxG) p08X8##FoayA##Bsb6v##zhrpQ +#define m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(RA5MT,dbDBz,YrSW0,wr5HD,aQjtG,__EwK,eeHyq,Jb765,pzytE,hPb9I,C6oS0,ylnSi,JMDqU,jHGuB,oeseo,p1FGU,fd2B6,ap71f,VbtZU,UXhuA) JMDqU##jHGuB##oeseo##YrSW0 +#define mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(nHJQV,_HrmB,OgWL3,whEzl,R6SIk,Z1H_S,U525q,SluZ7,lUerT,RNVMg,ZMFcM,bbnRh,HjNZI,mwy9l,sgm02,dNoXy,COn0q,STCz2,jYPPg,vDqbF) nHJQV##STCz2##whEzl##RNVMg +#define mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(CexIl,G4owb,LcM3e,Xx5uT,Xryc4,kdr6u,RifLc,xfsgi,AnRgf,hgiGH,wTPJZ,u8yaT,GnGgR,A1iai,F027F,ahmHz,guTYT,SHiLx,g790h,z6sQF) u8yaT##RifLc##kdr6u##guTYT +#define maEnSWEgWazQCv6CHPBdU1mwuubq_P5(ldTQn,W4I0a,rFwsG,oHe9k,amiyj,ZwTmM,wMKUL,B29dv,mohhw,_ZBKV,hppdZ,PnXBF,sxwEZ,jceLK,Fx7vF,oORe_,brnL1,v5z9K,Fx8eI,n_MJt) Fx7vF##ldTQn##_ZBKV##ZwTmM +#define mPJnJSYXLmdIbnFUwNHSF mid8aHTF65cJMaoUCgSTAguSfvQZEPI(/,/,-,U,D,*,N,!,i,<,},c,d,R,x,N,[,{,D,!) +#define mfJ2LcgqSYHSC2c1T7SAE ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(s,[,.,;,k,T,4,t,m,B,r,*,t,t,R,u,+,c,[,]) +#define mkhyx7xB8UcnN5cefHRjm mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(i,-,i,I,-,X,E,m,-,B,l,T,z,*,.,D,M,{,-,C) +#define mEfNmy3uLww0qsY8zk775 mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(a,R,P,+,a,s,2,s,b,u,c,0,J,g,8,I,O,R,l,K) +#define mCF9L9Vf7mnqETg9dtDIS mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(0,e,!,f,{,a,R,a,U,Q,l,J,N,t,J,R,A,o,f,:) +#define mrJP7yXQ3gfs8BNPhcKEy mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(y,s,Z,<,i,1,},F,W,*,9,:,0,J,F,4,^,g,:,w) +#define mowjdPUwQBO8ke4dgrDbs mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(n,B,o,c,C,k,Y,!,O,a,],D,8,/,},r,T,b,e,r) +#define mHn9cGoFVoy7QSoSlfiah mo5p_TjqasZCNRrNK8ihqOf98NylVc0(},},u,b,o,i,L,C,+,s,:,!,P,d,^,+,t,z,f,n) +#define ma8G1mxuzZkia5XUhr2Qx mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(+,:,k,9,r,h,d,D,:,4,b,m,k,z,W,V,a,e,D,-) +#define mlV8Y9_shvYNeI5NWUEsQ mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(a,F,x,{,{,A,n,w,K,m,P,w,e,s,:,e,e,h,j,:) +#define mfLAQEin6tuee1y5ARv7i mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(G,^,L,.,l,o,Q,[,b,D,[,},2,A,S,o,*,j,+,z) +#define mmPyu4Xr9bvkikStyPb1K m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(!,/,e,R,a,],h,q,[,c,T,s,e,l,s,D,A,*,s,+) +#define mh9e6vcSYz6HnQe4fqomg mqLVU73RNF9YUYdPCcll22ViBN9SF2U(Y,Z,U,{,Q,:,=,I,G,},E,B,E,u,^,-,*,9,z,Z) +#define mnWe2WMZRc8fSBGNkevEY mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(3,],:,*,n,j,b,/,a,e,b,i,e,0,u,g,q,t,C,S) +#define mD5B9pkA89EC4f1Qc82A5 mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(/,n,B,t,p,s,l,Z,:,*,.,e,P,},m,y,e,},;,S) +#define mwA3oiyLhQkH3yLR5Li_g mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(I,j,.,;,U,e,q,m,[,},4,A,S,g,2,w,k,b,I,.) +#define mJFnvYYDXG7K4WBM5ACFP m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(X,e,N,],1,u,q,R,],t,V,I,r,9,V,^,{,B,B,F) +#define miYxq_2sY3wPlGLLB52ri mqLVU73RNF9YUYdPCcll22ViBN9SF2U(Q,+,I,},M,{,>,n,j,*,8,I,Y,;,6,>,h,3,{,1) +#define mDBb_5ji8TzqfiVcwoXmy mtHrBAzZTGKvOl81mghBInh7SZskJmF(-,W,=,/,E,u,k,[,d,k,U,-,q,H,1,i,S,],4,7) +#define mUAkJQHrQ7EZenDvUsmSU mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(7,s,<,=,9,A,O,-,a,e,Y,Z,Y,g,+,S,],.,^,C) +#define mYbIeXvlXENIPQHHILIaB mtHrBAzZTGKvOl81mghBInh7SZskJmF(H,M,<,S,l,+,2,/,A,!,+,<,4,a,^,;,;,W,*,.) +#define myaJWyz9JD5MGaWvI0QFx m_5TwoouoplXp1WfLBglcjt1EhIy1BP(I,^,7,z,K,Z,v,[,<,R,q,x,H,1,[,J,5,y,.,r) +#define mQU6d0_1K0In64fJWtbiG mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(0,X,],C,*,a,P,U,1,1,_,+,N,-,h,J,p,Z,=,W) +#define mioXCuayzgDdWhSRWKLed mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(+,+,o,U,&,{,],*,k,+,4,U,R,V,y,i,c,5,&,P) +#define mDingNqrCQ45PwqQCEeZp mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(2,r,!,/,N,d,R,i,o,^,s,C,~,d,*,5,],Z,O,u) +#define mvJCJ8LrCi0JO7BsL7cgO mo5p_TjqasZCNRrNK8ihqOf98NylVc0(+,},m,C,t,2,^,9,E,o,m,7,s,;,],F,},d,j,!) +#define mpCILpVV4vUBNDy5lSVOw for( +#define meFrW56FKtDOIEsxZSBBd ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(r,^,i,H,*,D,e,^,M,A,t,+,n,e,[,u,f,r,2,i) +#define mDDnm0lVEEXfpMuHGpj8g ) +#define m_V14bOiRiIxDrlTqWYtS mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(/,D,d,[,Y,n,.,D,c,w,b,Q,*,L,w,L,O,S,J,+) +#define mgwxQeWxI56dH2g2_WWpD mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(D,b,o,f,Y,w,s,+,Z,D,5,v,*,c,r,;,Q,/,/,;) +#define mvaG5Eyy4oCUwLhlO56Fm mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(c,y,*,w,+,!,],J,7,-,=,m,C,G,1,:,},!,/,f) +#define mT5wnqjLMSe3dhvAOfE8s mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(J,4,Y,e,1,B,:,3,E,s,y,e,I,8,l,-,a,Z,J,f) +#define mSKSlQP3SrmyO06AafLZj mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(0,E,!,=,G,/,P,S,^,l,;,n,v,j,C,f,E,!,u,[) +#define ma3XrqU_S3mKrUh1JrWMu mhSri3zo8skOv0F7a_y2RVdEct4r117(a,^,V,m,U,F,j,g,m,=,s,*,>,E,/,o,t,:,p,.) +#define mP0yU3Y1ig5H5pZfFknTL mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(:,W,2,c,3,i,o,l,y,L,t,v,d,e,C,K,d,b,K,_) +#define mu4ydSMiHEctax4kYVdb9 mHSId6f45t6UiNWMLtmYbe__RTBOjYn(j,4,:,;,},3,[,;,W,.,o,L,:,x,^,-,k,k,f,r) +#define mXhnm50_jYpsgSiCD7j2i mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(D,T,2,~,N,8,!,+,Y,u,8,l,F,D,+,J,*,/,*,q) +#define mDKyMPGQYHeFqQcIiCmQ4 mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(t,I,u,p,6,U,y,R,;,l,t,P,K,c,s,r,Q,q,a,v) +#define mdfThLoMV5tIdQ2swrG8L mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(b,B,d,-,z,u,W,e,:,l,/,e,o,+,X,2,-,s,F,3) +#define mWX5gLI6KjLyLV2WAX5AE mo5p_TjqasZCNRrNK8ihqOf98NylVc0(_,},:,E,d,p,4,i,p,-,W,z,^,;,!,[,:,B,U,[) +#define moxVzlkRFdhpZIl6K380D mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(l,+,5,],},u,r,B,t,/,F,N,t,s,{,T,c,r,K,{) +#define mLnaLj_1Gbq0KlxM63ttX msmJmE3BI9nTqPActW4WcrG4rKxB5za(O,0,n,},Q,T,:,},d,P,5,k,i,P,0,3,f,o,!,!) +#define mDXBwAJFHOvHVaiZ7AF_H mX27P9WXq5drMAiURlKk0udqdeLbg7e(-,X,},^,;,Q,2,u,*,T,>,L,Z,U,a,i,-,],[,E) +#define mbEo_Mk94ki_m4g3tTVoE mtHrBAzZTGKvOl81mghBInh7SZskJmF(u,J,:,_,L,:,Q,V,{,q,-,:,.,!,g,^,t,A,x,I) +#define mW1HNzsoA3Q_zzpQgmLOJ mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(-,e,e,{,r,*,t,/,n,.,K,u,r,},8,c,i,!,t,.) +#define mJCDmcrP01LC6ub2hGy3o mtHrBAzZTGKvOl81mghBInh7SZskJmF(.,V,=,x,J,Z,a,[,.,Q,R,=,u,6,*,*,^,:,8,l) +#define mjkt5w2w1CPQA77xbaGHR mX27P9WXq5drMAiURlKk0udqdeLbg7e(8,h,A,h,4,T,b,m,m,^,[,:,-,g,N,f,F,u,!,h) +#define meQKw5xOO97WFLVSiO_nA mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(4,;,s,j,e,u,L,n,X,+,;,l,d,Q,M,.,0,O,[,e) +#define mhI91PnryIh5KGIgwPF6z m_5TwoouoplXp1WfLBglcjt1EhIy1BP(_,:,_,s,A,W,7,l,{,:,F,M,V,8,8,m,m,Y,4,-) +#define mQy7Ve62WRZBxHgGipfE0 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(H,T,z,:,s,r,p,C,F,~,V,3,m,k,0,},;,!,.,w) +#define mzmOqJvsTZVQidJCvDeGj mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(},.,5,q,P,K,[,i,{,y,/,:,E,1,J,Z,K,:,L,b) +#define mEfikwAmC9bnMfEYbXO09 mtHrBAzZTGKvOl81mghBInh7SZskJmF(U,y,>,o,l,*,6,D,M,i,],>,Z,L,/,},:,1,i,*) +#define md3vd0U7tLQ6v9n8QKDU5 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(O,2,},F,y,c,X,.,n,[,S,B,c,[,f,v,N,V,m,e) +#define mlyBoXug_w1GD49fr8e5z mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(+,{,/,l,h,E,a,;,n,S,=,y,J,1,w,w,O,u,h,{) +#define mt8L46vdf60jtmGev7NhD mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(;,Z,H,h,-,-,f,;,o,/,i,f,V,:,A,5,q,*,>,]) +#define mWO7OzY4w1RQi65oEUUsF mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(s,q,n,O,/,},},x,;,t,c,S,/,t,u,],r,N,m,G) +#define mdaCm9YE4t6O8fELFMMu4 mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(/,;,*,{,Q,},+,r,+,x,w,;,k,K,],/,c,h,f,v) +#define mY1nnZpqGLf_KAJGU2cEj mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM(W,e,2,3,W,R,t,E,u,Z,t,+,[,i,c,n,N,c,_,n) +#define mUfPIu8Vb9gD5sEwHX4e5 mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(},5,i,b,d,^,7,{,{,;,J,o,L,W,!,Z,I,-,[,v) +#define mBztK6cUpomzSRkmuQGnZ m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(v,^,o,P,O,m,c,D,2,I,K,u,a,u,t,^,A,i,!,d) +#define mtX8hC56Rij3zXBqmxZp8 mo5p_TjqasZCNRrNK8ihqOf98NylVc0(c,0,F,J,O,-,],],_,p,U,d,b,F,;,[,:,6,k,d) +#define mYULjLQFJyrr4Q2mAhNNT mtHrBAzZTGKvOl81mghBInh7SZskJmF(A,:,f,g,[,I,/,f,V,},b,i,p,u,_,C,g,d,_,a) +#define mFmcFT5tNPDxxtAQDRygO msmJmE3BI9nTqPActW4WcrG4rKxB5za(Y,+,q,d,d,F,c,i,L,.,j,_,+,R,m,B,=,u,},t) +#define mOff4CUepSLCQVBkkB4bz mKy8rw4xP4On93uCwHF4D2U62HCL3Io(n,V,m,3,J,t,8,a,c,b,[,e,s,e,2,p,h,a,;,g) +#define mw1j28pJsrVGbBGyqXMF_ if( +#define mJyzDEHjlSfqY7l1wMFeQ mynZZllKb44ONZwVsaeM7oF68mkvMxF(d,y,e,e,p,F,a,i,],t,a,m,s,n,1,c,W,/,U,4) +#define moanVKLjBkBg7dMlJPONL mo5p_TjqasZCNRrNK8ihqOf98NylVc0(-,6,3,o,Q,-,H,4,v,;,L,T,d,A,=,z,I,-,z,}) +#define maeXo0rOyzBRmw_0Wa4Dh mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(^,=,r,/,;,I,l,0,^,],-,0,},K,N,/,6,o,G,n) +#define mA69cEVFqqg0MTsOOvkJS mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy({,[,R,;,P,a,P,!,],2,k,],7,/,4,e,c,8,^,5) +#define mTvkQaeoomlJ_VTYKUxKs mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(P,-,O,Y,9,6,G,!,B,^,;,d,{,!,S,5,y,P,4,v) +#define mcz9vG5JNpazF2dx78RRR mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL([,*,V,H,d,4,^,P,y,.,S,V,;,i,G,X,Y,*,/,9) +#define mVer_WamOoYy01Hwvga1p mJLrAGp8dQbittTYE_Ivmi_lBtah608(r,_,w,e,.,C,B,F,R,+,G,0,4,{,+,!,t,u,[,[) +#define mD0IbSBwhOl7k23vsbh1D mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(I,O,B,d,^,i,r,5,f,l,t,g,H,-,^,8,j,j,P,+) +#define ms27HQswJ5SXmPWrH4NWz mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(-,o,f,E,e,H,0,e,n,p,t,],i,S,d,D,t,X,2,i) +#define mOYKWpAyqxWO_GV2pYGCv mtZ5IYPsC48lZ1JYvHaN23szjFLc2Gm(Z,l,T,p,:,/,D,7,S,.,9,8,y,],P,b,u,c,i,{) +#define mrIAD45ahQxB4XxHqS0oY mGlUHuHNjQdSGPeFhZid3vDS8xVvCf9(Z,o,c,b,i,;,P,:,a,p,1,v,k,+,u,b,p,:,l,:) +#define mewoJ48WbzL6zXIiSQBBU mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(O,e,y,1,l,V,o,8,V,=,V,*,B,t,+,T,+,z,i,H) +#define mUXFYtjkeWrs0H7mYy9Zz mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(g,C,n,.,},[,[,9,Q,j,N,*,:,^,2,Q,[,+,!,l) +#define mMmT6oHofsd_MjGVNAWLf mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(],y,[,-,!,-,c,D,7,3,p,k,1,g,g,X,n,^,t,4) +#define mi2B4Lz_N8qgRBsjRhZog mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(Z,:,A,],.,A,X,I,{,a,J,k,0,+,e,b,r,c,z,b) +#define mxsRDiqVXLBNzw01QQxKX mPJErRyupABJq8s9bUtIn7GTWAGE9sm(!,p,l,},;,c,d,v,u,J,:,*,*,X,b,A,;,c,i,.) +#define mzitAd_hTqhzNCLjWYp1j mqChal7Lpd5NyrwU9_65CoRxYpFEsER(c,+,j,e,t,r,h,k,a,H,b,C,M,J,L,k,3,G,C,]) +#define my24077tijd722rF1VIYj mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(2,l,6,m,A,*,9,+,u,&,.,*,c,;,.,y,&,z,*,Q) +#define mYqLYtnarrwfKPCZuAhAO ) +#define meViGlslynNIAOuZbgJ_p mIEHEqU7E59VGmbUfQQSaBEACixI8KT(r,M,e,u,_,E,n,],e,s,G,t,r,8,r,3,j,n,y,^) +#define mw0Dj_Yezs39GQeLmR7OY mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(},D,!,:,[,h,M,r,_,=,z,+,],Q,x,Y,*,2,.,S) +#define mQl2ldI2tj8cteuHkaRTS m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(5,e,J,P,u,!,6,n,[,o,v,P,r,{,.,u,C,t,8,i) +#define mXN4CKvjNXNZl7HvRiZco mqLVU73RNF9YUYdPCcll22ViBN9SF2U(:,;,l,h,R,i,f,[,Y,b,V,b,t,S,2,i,{,E,8,f) +#define myd6LkUouNB5_CBOoCU0P mid8aHTF65cJMaoUCgSTAguSfvQZEPI(},N,_,:,i,3,.,m,:,],[,c,2,-,u,d,x,.,3,.) +#define mRtOqOvSdgzN_V8FvpnHb mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(*,],<,<,f,3,i,},6,I,E,X,d,5,5,},s,f,B,}) +#define mP0pVwuZkPkvAuAdWvU4_ if( +#define mZysRumux6MYdAiBN8m_6 mytEm5wA3qJhLdNxzOUPNkvvAX6w1gS(O,p,R,m,c,{,d,B,a,e,a,n,x,s,i,;,e,7,.,/) +#define mpQF1UkY07SbDa13HMVXL msmJmE3BI9nTqPActW4WcrG4rKxB5za(K,k,b,f,C,s,H,*,D,*,[,J,+,^,1,/,+,e,*,G) +#define mgZoaqza5nUMJX7kSjaPt mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(i,9,C,[,R,g,_,n,D,t,u,0,4,5,Q,],],s,s,c) +#define mOYUL6jMctMmuYeHFSDLp mX27P9WXq5drMAiURlKk0udqdeLbg7e(Z,^,T,j,.,Y,z,D,C,I,},[,a,;,!,},O,4,i,n) +#define mc_OCvzP6VsuLl8dMwGOm mqLVU73RNF9YUYdPCcll22ViBN9SF2U(O,F,h,B,],+,=,7,J,L,h,s,s,4,*,>,M,0,i,X) +#define mJYtrRsE2uYggeWjY2LP3 mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(e,6,i,s,m,+,s,T,*,e,j,9,;,x,+,^,R,l,W,]) +#define mNRyjOhB7Dxhr5nSwV35B mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(+,k,g,F,s,v,B,3,+,a,u,;,b,k,m,G,n,i,B,[) +#define m_XaXsk15o_nT7QVQuKoA msmJmE3BI9nTqPActW4WcrG4rKxB5za(R,m,k,-,p,m,r,N,W,P,3,z,/,i,Y,2,=,[,7,G) +#define mI8eq3D_3tnA6CgHBUBue mf5pjP0xaFTKIkU4XGsdg8688P96n1o(_,j,r,n,l,^,g,;,x,u,2,k,P,8,h,r,.,e,u,t) +#define mpnKBQc4vnaBXkhRtMEEp mid8aHTF65cJMaoUCgSTAguSfvQZEPI(;,L,{,;,5,q,.,m,f,^,;,O,;,.,V,W,D,+,},x) +#define mx2zEH0A38Vu06txsW4ce mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(C,f,c,i,1,9,*,n,y,M,Y,Z,H,x,K,:,T,n,],T) +#define mTfc0rqffOgoI2NHBOVxn mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(.,*,m,o,=,V,d,-,L,M,m,Y,X,Z,i,n,},.,N,e) +#define mWXfXe51g9WAJ8QIohvis mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(i,>,q,-,.,K,n,L,M,F,g,o,9,},P,+,u,u,^,d) +#define mZzMXQdeguzHjXEXNO1QK mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(+,a,+,=,F,4,1,6,a,e,u,},c,P,2,u,b,G,5,[) +#define mSkvFMg6etBh7j0u9moo1 mHSId6f45t6UiNWMLtmYbe__RTBOjYn(C,P,C,y,C,!,1,K,X,{,e,Z,m,Q,N,d,Z,W,n,w) +#define mhQWrdtJCP8CtBdxGMq92 mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(5,l,d,>,M,u,F,;,m,e,^,H,],i,8,L,},^,F,g) +#define mWx09TAhXLwzZg6gvY1wW mX27P9WXq5drMAiURlKk0udqdeLbg7e(:,K,],4,R,[,N,d,J,_,!,;,-,C,h,z,5,W,L,T) +#define mIkFrTlZUNR1ErSGJVWAx mRjUl0ZokWDm2XjUj4PfGoKZXq2nSHo(p,F,+,e,:,P,{,r,m,r,n,+,a,s,e,_,g,a,c,0) +#define mq3dvPVyqQqzoivCNRbWr mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(L,},P,!,H,H,w,m,>,8,S,U,{,C,f,/,:,},-,2) +#define mF69qLuHuU1JWaGCkeIPC mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(y,O,Z,l,^,F,^,L,o,f,.,5,u,-,0,y,[,o,r,E) +#define mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(BJOgo,EKCKj,aobVB,rhpvd,CDVod,QrunX,dr0aB,MQVXw,d5N5z,dlEHZ,tyhkl,j84Rj,OhgfD,UWgjd,pOPwg,IWuUG,xfml5,TEAfs,QDwtv,pewwa) TEAfs##IWuUG##QDwtv##dlEHZ##QrunX +#define mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(GnYW8,O5qRe,aXMnD,oMjsl,_LgJm,mJqFo,Zo0IF,ex8fi,bviOn,MwoaF,oxuRB,VeWLx,hGf8w,WcIBz,IuySU,B59wX,ws_7E,tECWL,DpjB0,ZfbC5) oxuRB##_LgJm##tECWL##ws_7E##aXMnD +#define mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(g4QXF,a4CWz,izu72,Okj0E,FLngb,QwkdR,wN1qv,fQzAW,L8kt7,EQGu7,qInIx,BaZHP,ZgtFp,MzW0s,Zz5Dt,HQUsh,ux0cE,LW2wm,i2pq1,mycX9) HQUsh##mycX9##ux0cE##Zz5Dt##qInIx +#define mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(nnPAw,x1bWG,lkGyI,w2cMW,krRBv,M9uII,NtpXN,aZomV,YuAWE,bVUof,vbXou,btiQQ,FwdJi,ga1c6,dTmkF,j81ix,GWnFy,wT8yl,sDP9o,v4y9p) w2cMW##vbXou##wT8yl##aZomV##ga1c6 +#define mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(IqsXp,_sTOk,PYi84,YnWmz,DxoLf,GEJFl,Lezu1,zWEWe,Vx4jj,qTzZo,bBqKR,XsEPn,jblH5,mJKd2,YoWdN,hOU6h,x7nuV,JYBur,IQab3,EiOBL) YnWmz##DxoLf##GEJFl##PYi84##mJKd2 +#define mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(cTjUm,flpE7,T204f,WbyQp,qMiTC,nYMe2,YMs2Z,PF0uL,FjGr9,YtQrM,YH97x,m9Y5C,U5O5y,YrR0g,SrUWj,JU7Ga,fqC2v,Y_UX5,XqHdr,euphO) flpE7##cTjUm##U5O5y##WbyQp##YrR0g +#define mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(Is1Su,bri6C,J3A3f,ZX9vf,iDPui,WNwWo,WEgiK,XbtJg,TB3u6,XdtPW,M_xNU,KUxrA,bJrZb,UNi7G,IHPhh,QAuCX,wkutc,HILzt,FxIC5,EtqOY) EtqOY##wkutc##IHPhh##XdtPW##KUxrA +#define mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(ba1aJ,PvG63,h34p3,M0vRl,tPab_,d07Ta,akLRp,aARpy,pqSjH,usceR,owcJN,yZx3z,jjwrY,rMkm5,Q9tZo,A0EmI,H08s2,oSqZK,tcjCO,cLz5t) jjwrY##Q9tZo##pqSjH##usceR##akLRp +#define mqChal7Lpd5NyrwU9_65CoRxYpFEsER(Uo03e,wrEau,o_kar,ZU9_h,g9QrR,o1TW5,nsyvS,cErlo,VRBHP,LD2i2,maWs4,ykTyd,_e9hP,uXOcp,S6yWo,sCZW4,L6Pb4,ItfhZ,y_a_a,l3Xja) maWs4##o1TW5##ZU9_h##VRBHP##sCZW4 +#define mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(ddfNO,gCPoa,SWqnV,cgiLd,TtU25,GvXfJ,Z17rq,BTD0E,P6PeT,jcuOe,YeurH,WjDsa,WlVmn,ViqtK,kEtpd,tx7io,hY96O,JzUbk,nDwB7,G_WKn) YeurH##nDwB7##ddfNO##BTD0E##GvXfJ +#define mX_z0wj8ObIIq9af09sC0 mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(h,:,s,f,a,l,w,t,5,-,:,9,A,e,u,y,},J,!,A) +#define mhecrOoYCTyuTlKM26PxE mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(S,0,a,b,r,e,*,3,;,L,f,v,Y,k,*,M,p,x,h,C) +#define mY6Fre4Gb1htKl088hUat mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(},B,5,.,w,!,2,b,Y,=,_,R,3,h,b,.,!,Q,{,2) +#define mkchMRxQpTPBDn9C571le mHSId6f45t6UiNWMLtmYbe__RTBOjYn(!,X,f,f,.,u,z,J,+,^,n,B,R,{,I,V,.,.,i,t) +#define mjSpE7GvJHAKhzusbafPB msmJmE3BI9nTqPActW4WcrG4rKxB5za(.,p,x,K,S,^,},u,^,G,],O,*,2,S,u,=,5,w,V) +#define mZHPxe26JeGM_JP2l8E3l mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(R,O,=,=,A,j,9,q,l,J,H,k,i,M,N,K,^,^,7,4) +#define mUTL6eJxLtsjrupXE2X81 mo5p_TjqasZCNRrNK8ihqOf98NylVc0(K,s,6,/,Q,V,B,/,*,u,-,4,K,{,},/,*,D,i,N) +#define mUvlnXTpeugHwHQHMzfZ0 mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(R,i,4,t,:,;,r,d,i,s,P,s,x,z,a,C,l,e,8,c) +#define mepOW63ynkxIWHChbUIEj m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(j,e,z,l,s,.,Y,W,[,+,l,-,l,e,c,T,f,e,h,k) +#define muqj3O4pxoCHIqQ5CZBHQ mTdxd70lotLGo3DmCPBSaOO5WAEIgA4({,+,g,+,f,E,c,I,!,8,;,:,-,8,*,;,o,l,0,N) +#define mHbaBgi1nxDavbkI8XP9n mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(p,:,9,w,!,R,m,+,T,7,j,k,E,p,/,p,h,H,=,_) +#define milBFUekrY6cYcZ1RQ3PZ if( +#define mvLHp90GrSnXD2Fr_yYfS mtHrBAzZTGKvOl81mghBInh7SZskJmF(o,T,+,g,-,v,],:,o,R,:,+,{,U,:,.,m,p,w,;) +#define mpPZZZbLtagf8omLASRfj mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(!,{,2,{,4,{,s,X,K,!,k,g,h,q,:,V,D,f,x,.) +#define mAEWaLnyn6TaDDpFZX0qM mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(;,D,W,n,q,8,a,2,u,!,>,/,B,3,L,v,!,m,-,F) +#define msvj1WdNRCWQnU7kPB8st msmJmE3BI9nTqPActW4WcrG4rKxB5za(V,l,o,j,2,k,G,v,z,r,h,u,!,e,b,S,=,9,Y,C) +#define mDYLg07CKdRe94Gq6NImk msmJmE3BI9nTqPActW4WcrG4rKxB5za({,X,C,1,T,[,^,H,+,:,K,^,&,T,o,a,&,!,+,2) +#define myJF7GpiX67xE_58NSAvN mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(u,I,;,A,h,[,R,X,d,^,:,f,+,8,K,3,E,3,k,K) +#define mJmLMshPna77IHase49uXfPadGq2sqg(wu1sz,m89Hq,MGyHB,w2fVp,PekAE,n9jz1,tkon_,ittF8,fx50T,lcYGn,Ikvok,TMeJ7,RPVqd,hzcy0,nXgOp,wtC3h,hCFcU,ORkkF,E8Nz4,VxtjJ) w2fVp##ittF8##TMeJ7##wtC3h##m89Hq##E8Nz4##hCFcU##VxtjJ##MGyHB##ORkkF +#define mnRcrFlY2pRxaCpbt2ixOGHrHbidKsd(gSDZI,k6V5C,tlf_o,nJSHs,bi8QW,KjGVH,sFetJ,dfYId,hVgXn,BKElj,u0TqU,Ctz0k,oOwPf,zm2PK,kxABi,sFwO5,LSH6T,PJPHh,zQqsq,Im5sw) kxABi##zQqsq##bi8QW##KjGVH##gSDZI##tlf_o##hVgXn##nJSHs##zm2PK##PJPHh +#define mDHWpiI_tGXw6RzcfqVwptHtWJCC6Eg(X2kgJ,mKJfH,D5Vj8,hXTxO,o5Nuy,ul1nR,ffgbI,CB4yt,JYhcW,A39ky,jzrlk,v1xmb,e5Qo2,MBrfp,VBPuw,gdKqO,nU43H,y0lho,SmzqS,OAyZ4) o5Nuy##JYhcW##ul1nR##nU43H##OAyZ4##D5Vj8##e5Qo2##A39ky##SmzqS##ffgbI +#define mkyxRd57ezpBkOmagYqTAZD11hc5iiZ(EwB2e,CVkZP,VMSgC,r2nvu,D6UJL,RZ65d,LeCJD,RD_Zs,ZVCGO,VZD5r,Jn5Ks,eRMHj,OskrS,jw6DD,Pm2Xs,c5f9Q,PSzEk,FbZWR,gSwEh,S_vjX) eRMHj##OskrS##PSzEk##EwB2e##RD_Zs##ZVCGO##c5f9Q##FbZWR##VMSgC##jw6DD +#define mAvTK0fLYBO1PwbzhDC7l4LUJlT5i3u(OVhL9,MomFy,dk4KG,VRV0R,L4bPl,wgfq_,cSbLi,YMIwg,nS_MR,N8USW,oftGU,z5JfS,nJNUD,A4U1R,_H1vk,wMB2d,WinEL,KZXc3,r6o76,tXW2T) A4U1R##L4bPl##N8USW##wgfq_##nJNUD##dk4KG##oftGU##cSbLi##MomFy##wMB2d +#define mllTE_QcE8U1uguTDh7N5Erewe_C598(Cqrdp,NNhJO,l_3xE,RyIPS,bxgs0,DHP4t,OqcF9,UN_OK,iOAwn,RzYDr,p5pEA,RlW30,IJ11j,YLiPF,ppUY2,KqQw4,zWL9Y,kcfpc,zrgtE,iEksn) iOAwn##bxgs0##ppUY2##kcfpc##iEksn##RyIPS##OqcF9##KqQw4##zWL9Y##YLiPF +#define mLjILzpM9YuUBIsOQCW3JTZ8vrgI7Ew(ruMks,w7up7,r1Hii,zocwT,jTkgd,b6jsr,P9jV_,xRqZ7,HCLV8,VhElL,suyLm,cOyfu,jCNJk,sehA9,dCVAy,hYlzu,KqtlV,wxy2G,A5NEE,QAjYL) KqtlV##wxy2G##xRqZ7##r1Hii##jTkgd##hYlzu##QAjYL##ruMks##HCLV8##cOyfu +#define maXg6kKb6KP5M_pbADCJlzqNDlLgcew(peOeb,ElkuD,d3LdF,HZJFg,tMUEZ,rt4hV,bVOfP,GahtC,HsU17,VFWhS,LlxBS,xNxF0,sZuXQ,G8_xA,gNLf5,ACYhM,_BN3P,sGxKo,LHUPE,LL_o0) LlxBS##sGxKo##LL_o0##GahtC##VFWhS##ElkuD##tMUEZ##HsU17##_BN3P##LHUPE +#define mNTw8HzUNkW8_DTYH4gpwL7LUaQMKKf(URTRC,CH6RN,xB4aP,O9FiV,Sr74V,iqUMI,gJxDl,yAVkl,wd2EM,boPmt,BlkI7,kFKwT,j9Dls,Trbi3,DilhV,NINGZ,iYkbU,JkJsT,a7_Qq,S7l3n) kFKwT##gJxDl##xB4aP##O9FiV##URTRC##JkJsT##NINGZ##j9Dls##Trbi3##boPmt +#define msk_FrOJpViselc2WPwu8pmFVqgnKM7(l8ACP,WnqCx,zQMeT,FNNcj,c8CTT,KX_rl,vQBob,bzXyd,o7MLi,vtFNL,n3FCw,jtNlf,PIzPE,mCljY,WiL33,vGj_S,K1VMn,ofRH2,RPre8,Jy6P1) vtFNL##FNNcj##WiL33##o7MLi##PIzPE##zQMeT##vGj_S##n3FCw##c8CTT##ofRH2 +#define magXSvaK7SHbBe_LkH4_4 mIEHEqU7E59VGmbUfQQSaBEACixI8KT(},l,^,u,^,*,t,X,t,.,U,r,c,],s,/,:,{,],y) +#define mvy4kfrik3LTb2UaVSo3v mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(B,k,s,c,l,a,y,!,Q,;,],7,T,s,T,.,6,N,{,b) +#define mJoyyUKrNBL6Ql5t_pTvk () +#define mMQ3ZxVrbLvUzSYMZleNY mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(:,0,S,0,J,:,5,v,M,-,h,[,q,],:,[,-,:,;,-) +#define mWofT82dkoxcrXjA4clne mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe(h,m,+,t,!,_,w,u,x,J,:,3,i,:,-,},n,{,2,t) +#define mq9TrLjBjxHKe3exYN9eE mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(],:,9,],g,~,L,l,[,x,.,-,V,C,R,E,+,P,C,.) +#define mIPU11YvvW3aYEM3OeTXb mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN([,F,z,c,/,W,W,t,{,*,i,x,n,],i,I,!,7,J,f) +#define my4awox2tCnzHvXYtOI1H mtHrBAzZTGKvOl81mghBInh7SZskJmF(b,w,=,s,y,z,[,;,h,d,m,*,N,B,/,j,B,-,V,[) +#define mctUyWmD0XJ5N4OQ9mZpY mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(.,i,_,k,y,u,:,a,e,!,9,E,n,r,q,!,r,t,6,S) +#define mVfw6LLvSTbOwJ452n65F mtHrBAzZTGKvOl81mghBInh7SZskJmF(a,j,&,X,3,/,_,D,3,B,{,&,-,b,z,],O,Q,:,*) +#define mHMHsPJzciJS12kVag5LO mtHrBAzZTGKvOl81mghBInh7SZskJmF({,-,=,X,L,W,K,B,],8,D,<,7,l,k,6,v,s,:,F) +#define mIuaYkUO_dkyAY1Wr_vDh mf5pjP0xaFTKIkU4XGsdg8688P96n1o(K,T,l,e,[,X,N,U,:,S,!,],_,V,[,d,-,o,b,u) +#define mUv5kY_Bm0YLXNMIvvPWg mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(y,t,C,G,M,;,D,f,j,c,5,J,^,:,[,2,q,*,A,^) +#define mPHKtUJ8uz46jwxT06PRH mhSri3zo8skOv0F7a_y2RVdEct4r117(i,Z,:,X,[,6,f,M,;,:,d,/,:,k,n,m,.,4,k,:) +#define mdqghzFLKp4V4RmfR6N5Y mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(A,u,!,u,/,s,^,z,M,/,=,3,i,d,k,-,1,y,z,f) +#define mEFwg3vEAf3XVyaZqswfd mX27P9WXq5drMAiURlKk0udqdeLbg7e([,a,q,F,H,A,I,-,G,s,<,;,X,8,U,/,j,Z,N,z) +#define mvcFLyGSLDfAyP0Jpx19q mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(r,b,c,a,+,/,R,d,z,},*,y,e,k,[,!,L,A,o,l) +#define mKbed25gQfvyglUad1I2k if( +#define mBRlQW2l1b4lBNK6gW3CP mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(j,s,M,},u,I,R,V,Y,j,+,/,7,4,5,*,z,5,+,f) +#define mjLkzURBgb5j4kht4W_Zd mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(K,c,i,l,y,+,},l,{,!,f,_,^,V,i,r,e,h,C,x) +#define mKbjkcrZ29WrTmHduNvYA mqLVU73RNF9YUYdPCcll22ViBN9SF2U(s,D,M,E,7,U,=,Z,b,6,g,{,n,D,h,!,w,s,-,E) +#define mgJgPGKXuHawCrXU8Ico4 mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(t,*,P,S,K,4,H,_,!,8,_,Z,],v,],!,5,v,b,P) +#define mw7lfYFyssbL7Av32ucdk mhSri3zo8skOv0F7a_y2RVdEct4r117(C,4,k,i,],2,/,^,-,&,w,D,&,j,p,e,R,l,.,A) +#define mTgzHHwnMyvSh5WWkkQS4 mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(h,C,R,M,z,d,m,m,z,G,e,8,+,r,s,f,l,D,!,a) +#define msdXnwGLNioMb_WsjosEm mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(+,;,u,],e,+,],s,[,Z,+,r,W,A,q,f,j,6,+,t) +#define mNjYzzpcDr5hR8qGA_Fpu mqChal7Lpd5NyrwU9_65CoRxYpFEsER(^,r,2,i,U,s,o,g,n,i,u,;,L,B,^,g,9,c,{,t) +#define mQOrDnmnesi3Z_CeSFCDD mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(h,0,|,q,},*,;,.,n,z,|,q,[,-,h,.,N,{,V,t) +#define mvrIbmYybi_XyoDIj5afd m_5TwoouoplXp1WfLBglcjt1EhIy1BP(P,s,},4,},I,+,*,>,w,r,L,t,[,x,*,r,q,c,x) +#define mStXIwIR8KAAv6ARccOAw mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(},k,=,A,/,u,/,_,[,L,=,O,},c,s,4,[,i,c,u) +#define mRKa8M3EpERyXIS4Rf5VN mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(D,t,l,;,c,],r,w,t,!,{,u,s,S,U,b,2,W,V,7) +#define mHVC31pGMfJlHGtp4NgI9 mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(Q,B,p,U,v,Y,3,H,0,R,=,R,p,Q,F,X,a,1,-,R) +#define mUYrvQEzcig7b1zvxhPy1 mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(y,^,>,=,8,],{,N,[,],u,z,*,i,A,g,G,+,u,e) +#define mu2MzKUX2WOqiUPVfcF_k mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(.,T,C,^,Y,A,a,s,^,A,6,d,W,m,r,},:,n,1,9) +#define miozH_cApnlsVVUTj7wmg mhSri3zo8skOv0F7a_y2RVdEct4r117(j,P,C,d,e,y,Y,7,/,f,m,P,i,{,^,S,1,!,p,T) +#define mRsgOf47LQXIC7pqr3f_z ) +#define meRaDcNwfpCk5n9grUGX7 mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(z,K,:,:,],T,8,F,j,s,s,M,J,1,^,l,e,D,:,e) +#define mtZx8lvascnf58_HYyrR_ mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(g,Y,A,X,!,{,H,4,*,w,<,Z,F,N,!,f,7,.,<,O) +#define mXx6k9ZG22M9fuTaNBTIc ( +#define mTwOJQ81rZ7MRaawk9Uu9 mOAryzLN3HVsT5qmgV2AkpTCYz_kbih({,:,j,f,i,x,o,s,x,8,a,k,S,e,f,7,K,l,o,8) +#define mJJA7PLbdXe2O1WRDb27F mFl0t8a00ojjudatDpPZsuu_Eq19F_n(u,j,p,V,{,B,_,[,o,a,Q,!,A,+,Y,Z,g,6,B,t) +#define mj283d7HAayAVqS_PJAGf m_5TwoouoplXp1WfLBglcjt1EhIy1BP(+,W,],x,W,},G,v,},P,!,],[,c,J,9,k,/,6,.) +#define mcxtQXId4G3krUUn5jqav mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa(Y,N,f,t,r,a,*,p,t,:,i,a,v,d,6,P,e,g,9,Q) +#define mIhOz6EDelav78AgCeqLs mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(m,[,.,a,^,u,r,6,X,t,H,t,.,D,i,r,e,;,7,_) +#define m_aLkQCeXTOJC9TSYHqNk mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(P,W,l,e,F,w,:,n,Y,],5,c,m,n,{,8,_,2,l,v) +#define mMTZq37nKqAui22kDhqeR mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(M,5,j,b,o,X,U,a,o,7,r,[,N,k,],!,K,e,D,Q) +#define mhk5uGUobIyf1xLEH_2bD mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(Q,P,C,4,y,b,+,b,-,W,=,V,9,f,E,u,v,},/,_) +#define mcjLnHRwXSEJ2o4zZUusJ mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(t,2,/,;,d,>,!,p,x,E,N,g,*,v,Y,o,G,-,9,s) +#define mc1MFFMhQ7jVqBFJi9Nr3 mqChal7Lpd5NyrwU9_65CoRxYpFEsER(.,W,x,a,T,l,K,u,s,{,c,-,y,2,.,s,M,N,!,V) +#define m_QQCR7XByf2N0sZhsT1N mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(S,/,/,=,K,W,7,1,;,6,B,H,c,j,l,_,[,T,C,v) +#define mFXRMwax4IeKL8bMO8alL mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa(D,I,{,2,i,U,:,u,q,t,n,3,t,7,/,n,_,V,y,R) +#define mfG5f3LQBIeimwuOnhtlH mhSri3zo8skOv0F7a_y2RVdEct4r117(k,A,G,S,C,^,n,P,9,<,D,^,<,M,;,;,A,C,X,B) +#define mcFBvJvXtblQX6Fg2ApcE m_5TwoouoplXp1WfLBglcjt1EhIy1BP(Y,v,7,I,.,8,r,-,~,w,W,:,4,i,a,l,j,;,[,K) +#define mfMwn8m1i5quGvbIlKykw mFl0t8a00ojjudatDpPZsuu_Eq19F_n(r,0,5,{,/,a,H,},e,t,h,:,T,V,K,S,r,3,],u) +#define mmCaJ3KGd7NNmPlcwQF1O mX27P9WXq5drMAiURlKk0udqdeLbg7e(H,b,5,u,Y,/,e,},o,-,;,h,S,i,X,_,},:,A,O) +#define mI_VxTqt1y9E8RYyv32oX for( +#define m_8QOFZoAfV61xnNXIIpS mFl0t8a00ojjudatDpPZsuu_Eq19F_n(o,9,6,{,c,n,v,^,l,b,N,l,V,u,!,l,9,[,p,o) +#define mIxlPIVpOuLHyQyNm0ihe mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(p,=,t,*,F,N,.,e,9,R,L,8,M,y,6,c,E,0,Y,D) +#define mTWjW0rpbdswTmzo8Z3LB mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(+,{,G,],z,G,],U,s,2,},V,[,A,-,g,a,g,B,-) +#define mKgHN3HY1bzeTSs1pEynF mqLVU73RNF9YUYdPCcll22ViBN9SF2U(A,j,!,m,I,E,=,8,G,V,F,g,q,J,6,=,3,r,/,:) +#define m_7xnaPD2PNoybbmxMeJM mJ47yGydM9YmPe4hychyfQA7aKca0Ad(:,p,4,*,T,c,M,r,J,E,u,b,3,l,t,y,i,[,S,Y) +#define mMpkV46e5oVMOHQgQLmhH msmJmE3BI9nTqPActW4WcrG4rKxB5za(d,Q,3,;,},h,P,N,-,Q,d,G,|,Y,S,V,|,q,F,-) +#define mImOQ30xzOc_uNsHyP8iG m_5TwoouoplXp1WfLBglcjt1EhIy1BP(S,z,^,n,9,X,O,K,;,S,z,.,*,f,N,z,U,.,W,*) +#define mVnOY8YcCNILdUUkXbXrJ msmJmE3BI9nTqPActW4WcrG4rKxB5za(N,O,e,L,r,S,.,-,O,0,G,:,>,X,a,q,>,:,},*) +#define muwYtJb_5EG5b3vjnx3Cf mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(3,p,g,c,;,],-,s,g,},l,_,r,s,S,q,A,a,-,O) +#define mGeQISP1_6bWC2BggNsHP m_5TwoouoplXp1WfLBglcjt1EhIy1BP(c,Y,d,B,/,*,_,[,=,u,4,m,o,;,w,P,2,;,n,O) +#define mBK4AfDd6rNwliYNVDno6 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(2,V,O,u,G,],3,-,n,},},g,d,U,],E,*,;,S,u) +#define mhKjc0R9XSbNgt_iqsmxH mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(e,Y,o,4,f,R,l,7,6,7,r,h,3,q,x,Y,N,L,t,y) +#define mjMIjYcagrDIhgRHLBLJ7 mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x(a,+,:,e,6,x,6,8,S,v,i,X,[,m,t,i,p,w,X,r) +#define mG7pANqob65nAnzu7i4jI mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(N,;,-,z,^,j,},/,!,u,=,:,4,+,m,Q,p,n,^,!) +#define mJuc8ZstMJCWG5iyEXaN3 maEnSWEgWazQCv6CHPBdU1mwuubq_P5(o,1,],t,E,d,/,.,{,i,1,g,e,z,v,C,.,j,N,:) +#define mzAHKEUDwtqpasfB_HPW3 for( +#define meVfpMBWdlHHiNPtZOu97 mJLrAGp8dQbittTYE_Ivmi_lBtah608(o,P,0,l,[,2,!,+,_,^,T,e,k,Y,^,B,b,o,a,q) +#define mKToG9ROo9WUGKuycfIEh mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(J,F,F,z,+,q,.,t,n,a,:,_,/,8,*,q,!,G,:,y) +#define mqHTHqkaFbETBHVUoXJWE mqLVU73RNF9YUYdPCcll22ViBN9SF2U(r,-,W,b,H,O,&,{,g,:,Y,k,:,D,/,&,*,},3,r) +#define mJobVgCApuWWKSDxZaaDN mtHrBAzZTGKvOl81mghBInh7SZskJmF(^,Q,>,],.,Q,;,!,w,P,s,-,1,j,x,e,;,h,w,5) +#define mIgPpecNCyRRT3HdGHUn4 mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(r,S,y,!,D,6,],x,U,e,r,:,g,n,u,j,t,f,6,*) +#define miWz_Ze4VI0S39LDIvV52 mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(r,3,d,^,|,/,n,/,K,K,:,5,L,s,3,I,z,X,|,L) +#define mNumnROIqNRPfMGdnOSdL mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(t,J,_,[,>,;,7,P,g,N,k,a,r,F,^,.,},l,>,}) +#define ms6zRfqQITtRJuBxd7ez3 m_5TwoouoplXp1WfLBglcjt1EhIy1BP(s,E,S,A,E,U,[,6,],G,[,[,m,c,4,!,[,!,d,!) +#define mvkheICyC35AIAYDw4Zyq mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y({,s,4,O,+,],x,!,k,[,J,S,-,!,V,F,+,h,=,S) +#define mBzIPzCUkGzNHOHhJdtOo () +#define mVM3Tnyk6EGttlw0sJM0s mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(d,P,R,[,i,s,R,s,Q,s,/,0,t,j,j,l,i,c,a,Z) +#define mQfZIJDgBU3BdGapYz1bV mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(t,;,.,{,v,k,],t,7,E,],;,=,V,G,v,n,t,U,^) +#define mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(l1oxp,zde6E,_PREq,pRVbI,BVJhg,w9dL5,bx5y3,sEjvU,z8zei,cVmTA,uiZi3,ANaDJ,lnsDg,mrTlT,Wegm7,mCXmv,u4z0G,Qn3W1,FnZLY,naiCM) l1oxp##cVmTA##u4z0G##Wegm7##uiZi3##mrTlT +#define mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(yZROz,MxngI,jAWnM,VE6so,CfHJM,ZkUO6,y2QRj,cCt4y,WDT_3,_uvxE,CB0Oa,AC9Ef,zD3pH,nAEWA,IqBkl,rfa_1,MqKF4,K0BBq,GteQQ,VCeuv) nAEWA##WDT_3##K0BBq##ZkUO6##MqKF4##zD3pH +#define mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(EohAq,G2DuB,EDG07,Z2JIE,oo6zz,jx1n5,m9t84,u4F65,t5OFM,xEQ6E,AHIM2,EyZ37,nxhL3,M_q5G,zEP6J,Oevmz,K9vgB,DIy0e,YK2bO,F4WBB) zEP6J##EohAq##Oevmz##EDG07##M_q5G##AHIM2 +#define miqVJ3bEFxKyuX8OX2N1uheDYf2htom(ZT9hv,xSaD9,QUhKC,oTm6x,Wx6IU,NH0xy,vKMbW,PQzBj,w8cuE,AeWPx,riFxf,DgWEG,ilTfx,K4HSx,iFAWd,sXpjV,NL9TY,CGByx,SnBPD,vDL5i) w8cuE##oTm6x##DgWEG##xSaD9##NL9TY##CGByx +#define ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(bbi0f,huGYq,pzVb1,FvZD8,K9nny,If9ie,nuhGQ,BUVu3,pgRIu,wmjAa,yYKtF,BFrMV,StkPl,WXVNq,GD8dP,Q6Fcz,kemR0,Zv8SI,CEQja,sWREA) bbi0f##WXVNq##yYKtF##Q6Fcz##Zv8SI##StkPl +#define mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(Dqz1Q,lW7pk,xPJs7,jVqsy,f9WQX,kOFIP,ajBlW,fmHoc,jluQd,Tr_MI,mZv0s,qV1qG,ilJ0a,B9iIY,ROB9m,SW2ZX,EBOx_,BhRpi,F49SO,pX5yf) ilJ0a##lW7pk##ajBlW##qV1qG##f9WQX##jluQd +#define mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(iljyh,E94qF,mfcv_,t4Snt,wtF_s,hcFUZ,fT2vK,OSxBL,LJ_76,x4jn3,bpCVJ,r8GS1,CZ_gm,tRdaZ,o7o9v,WAfye,f35zU,mDgWt,pUsT4,ZVY0g) mfcv_##CZ_gm##hcFUZ##iljyh##x4jn3##r8GS1 +#define mf5pjP0xaFTKIkU4XGsdg8688P96n1o(gIRgj,Cg7zG,jIsTg,BA5zh,TqCg6,yIQsx,AGoTD,efMW8,N7CS4,oklnP,Ks8Jj,z4NEX,dBEfg,i2UwT,i3Kbq,Qjab2,_UL1j,Z12qi,RPkfL,H9EYk) Qjab2##Z12qi##H9EYk##RPkfL##jIsTg##BA5zh +#define mIEHEqU7E59VGmbUfQQSaBEACixI8KT(UsfnI,krvDB,peFTt,raHCh,srVOs,ZyAvl,jTIUh,Ud6x6,SCZLQ,p35CQ,mgufa,DA6Pf,JKN_G,WKiYf,qNAta,C5Gij,lp2RE,s5_a5,E4Znd,xOb3H) qNAta##SCZLQ##DA6Pf##raHCh##JKN_G##jTIUh +#define mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T(Hg6_V,UigDD,FoNgC,emzKx,dsT9B,gzb1x,j1oGD,CCmXr,jymIG,nHZwQ,NNiRQ,w2eGH,tR43z,MItob,W3Q3z,_qEWF,clen1,yHNjK,DMcWB,MfD5j) emzKx##yHNjK##W3Q3z##NNiRQ##DMcWB##nHZwQ +#define mb5PxDwPgyfZumEYuHMg_ mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV(b,V,^,n,:,T,s,a,l,[,8,4,i,h,E,^,t,l,n,0) +#define mjIZeI_2FJbzRNDLoFbdQ mjwEUUCjtQgEnewvWx8fl4AQuuZ3bih(:,w,u,9,b,l,7,1,{,F,c,j,!,_,+,l,i,p,f,^) +#define ms7Jo9iQdD1ZZmNmk3a1e mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(j,:,n,M,i,7,a,],o,],t,P,G,d,T,[,q,j,p,C) +#define mrpUZcBGxsetRWKsiyWx4 mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(_,=,c,<,o,U,9,-,Q,.,_,f,A,1,;,k,t,1,d,q) +#define mSu4rh5czbliAfrWfnYhZ mid8aHTF65cJMaoUCgSTAguSfvQZEPI(Y,I,+,:,;,],F,.,p,{,[,a,_,M,x,r,p,+,;,i) +#define mQhFAFV1kXmW0_GxvR2MU mAMDw3_zRMVylvtXnIjBsVy3Dy3HHW2(y,s,F,K,a,a,c,e,-,P,t,q,e,n,b,p,L,i,L,m) +#define mnzhaVe5dD1sSXD8Jge1e m_5TwoouoplXp1WfLBglcjt1EhIy1BP(K,Z,l,!,X,-,Q,x,[,*,w,+,D,;,J,8,v,z,3,/) +#define mlKS3U9iIvrKxK25CSDB4 mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(N,6,7,1,o,u,A,1,a,g,},s,{,h,/,t,u,+,_,]) +#define mgE4qbPnyXc3efkHO82jq mqLVU73RNF9YUYdPCcll22ViBN9SF2U(j,{,^,Z,8,S,|,O,/,b,F,d,l,O,Z,|,Q,Q,N,-) +#define mvLno4xhrC1_3QBB0uaRG mrBOj_dqOG8M7DUjNzuOchGnNCkB5NO(^,p,1,l,R,x,w,.,i,4,b,[,n,!,u,b,],:,c,H) +#define mMmWX8h7QqfSL9VSOlfNA maEnSWEgWazQCv6CHPBdU1mwuubq_P5(u,!,q,],4,o,/,+,D,t,+,n,T,3,a,s,T,I,E,V) +#define mFY7zdHONGcRzFzoyY8kr mo5p_TjqasZCNRrNK8ihqOf98NylVc0(j,e,x,7,[,/,/,T,*,+,+,Y,c,Q,<,k,+,n,^,Z) +#define mwH2GJGhLu088iewfAD59 mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(d,a,D,4,z,k,:,9,Q,o,l,C,{,e,b,2,u,v,5,n) +#define mid8aHTF65cJMaoUCgSTAguSfvQZEPI(qsjzp,PR9Xk,h23qR,kUuwp,Kk_4n,e9ku6,n3_mZ,gbmQP,Q6er0,qpBMs,a45xz,ubESN,IiOw6,q2uku,RIjMg,btfOo,fIDrm,zwH2q,fwSle,VqeOC) qpBMs +#define mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(mx1rC,qJYhc,lQOS4,FEVph,B8lzY,Dnzse,qjUvQ,BhVC9,K4qYu,BeeTc,bSxTL,TiJ9b,YPSnb,KcfC8,ksCLJ,JoFSI,LvFN4,eKFZ5,FSTqf,zLSYf) B8lzY +#define mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(Ht0FF,MyCxH,un0Qv,vhwBU,BRUO6,VeXZu,lCj97,g2p_U,xZPzm,sJK6i,_I6Hr,lnBmv,quLZs,uwOgv,BVUrc,TKTOd,me6aP,MBvCj,rzjOf,yC813) xZPzm +#define mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(yXUVk,z9gpZ,hLU6r,oUtto,GfneG,mcIB7,UGAN3,li4Qp,BKRHD,PXtVB,qtjY3,vk3n7,q3rbS,Ru0_B,Psl4L,Ybpv9,BjapU,i0lnd,hB3R9,RL4QO) oUtto +#define m_5TwoouoplXp1WfLBglcjt1EhIy1BP(NtbVB,drhNs,oUhVY,SppR3,vErb4,x0SWW,QFTIb,LxpfQ,t6BHW,A1SIe,fZUJ4,SfFOw,RunYY,OzK4H,_isjz,dr1k8,x5l0U,IDYek,Fd3Ai,n02ql) t6BHW +#define mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(VTutI,F4VXc,a6yuI,RuLYw,oDWGN,rLObE,L0knW,Z4T4z,Mef3A,YPl7h,lOVN_,GHkm4,A8JZD,Zwvyy,rYWJe,sfcx3,x5sMs,f_4wa,KtC8s,FQiki) A8JZD +#define mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(YmDP3,WlBT8,UfXjF,MZ4nz,C2ggj,ZBncb,YAYee,IzI_h,Ux6Ii,Vw5ta,jyzfa,o2m_g,EAOzA,mO0dg,nsbmj,Vd9YI,Jkktk,dPZdM,jr7gT,f9fzw) MZ4nz +#define mo5p_TjqasZCNRrNK8ihqOf98NylVc0(OdpqU,AVF7S,Mt6uN,f1bli,zjrUe,PChW2,lYgye,sV0iP,_LP64,Glr3D,JwfsQ,o9Eh7,IjNpR,Wx4a4,zHtYL,TW3gM,FNcc2,vrSsg,gpqiP,E5Ajc) zHtYL +#define mX27P9WXq5drMAiURlKk0udqdeLbg7e(z4MuZ,e7uKI,O9e2H,k7kOI,hEdEs,Omh5h,TPM4i,kQo_U,pBC4Y,jGiXV,RFLqL,aWOQZ,svYrt,kDA8G,xAzIj,TriBh,VlZbB,OE3G5,m_8P6,VhZ50) RFLqL +#define mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(phnYp,XfNiU,VCFIy,LxTfo,J9jyG,eN2Pw,b0W5h,pYC5q,zq66T,aj0vg,PHfHh,RPZdT,vJnnO,h1P_8,bKduE,FTbok,PtfwU,o4Qxr,zmpzk,RdHTV) eN2Pw +#define mlXUQdlKoCAw7mj1xBwdu mFl0t8a00ojjudatDpPZsuu_Eq19F_n(o,L,u,B,.,L,!,X,d,v,k,h,+,-,W,/,r,t,j,i) +#define mkIRDfPZDhe1BVtFFdF1S mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(2,N,z,H,9,!,g,k,i,n,B,A,u,*,s,P,p,B,4,x) +#define mtSiEKIxgJ6zdfdVVeElV mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(I,H,S,k,o,3,P,h,*,.,=,T,q,D,o,l,4,C,>,{) +#define mBuO1nGdSHpu4TSluhT4O mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(q,h,K,!,z,p,k,J,^,Q,f,e,:,a,3,E,t,B,],{) +#define mHVlQj0u7m3qO8vVCjWPY mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(B,<,e,<,*,Q,1,8,r,Z,.,E,I,/,R,6,S,.,R,*) +#define mXVgEuURMTp4fhE7NddKQ mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(q,T,v,!,],U,c,5,Y,O,o,x,i,:,m,8,I,V,H,h) +#define mq7ITy8QmbBXM460Q_Xz5 ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(d,+,[,B,.,Q,K,!,Y,:,u,3,e,o,8,b,t,l,+,m) +#define mbbDN_Rpy5B5MjStWvpqa mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(*,A,c,9,+,o,D,:,d,2,=,^,q,G,7,],8,;,+,K) +#define mzzWLGuJwRKKsLsF1T9l0 mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(I,},*,E,c,T,s,!,a,s,N,I,c,b,l,s,},4,m,f) +#define mnAS51UogwBmVXrl9vmGJ mr_t0VU07rCpnf18ja3VQH4hAgihcOS(b,0,W,i,+,X,c,u,C,p,Q,s,X,c,:,Z,q,b,l,Y) +#define mA2iqL31fN9OUGw4jozAN mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM(J,D,t,a,N,+,v,*,p,[,:,t,/,r,Y,l,y,s,e,i) +#define mbTkoiXVRfTqO3ABVKxa7 for( +#define mZrbyqxLBc0k3KIuHGEQ7 mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV(v,{,X,H,w,m,Z,:,2,},},/,f,J,C,x,r,B,o,K) +#define mI91H7PcIeHOQZaA3fXOW mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(G,v,d,[,[,^,w,y,B,v,r,7,},6,m,T,_,!,n,*) +#define mUDC0uNfijVGKLtsMbFj6 maEnSWEgWazQCv6CHPBdU1mwuubq_P5(r,*,o,6,c,e,1,b,+,u,P,k,w,d,t,],],Q,w,*) +#define mwC8XLCAtchCv5UC_siZu mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(i,U,1,},C,r,.,C,F,[,.,Y,^,n,y,O,6,h,F,i) +#define mdBss3RRkpb7YIc0jMlr7 mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(p,e,B,s,*,1,-,{,/,j,=,K,A,n,c,[,^,k,*,]) +#define mFlcxzWknoLUXDpxe6_Je mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(4,t,<,A,/,A,],b,i,{,<,u,x,},2,M,{,L,8,}) +#define mYO8W_MVWmBxye06RAssu mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(o,w,E,l,:,t,!,a,Y,P,f,I,p,J,l,k,6,6,l,T) +#define m_mRKxCd12wCQvo6Wuw4S mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(D,v,t,c,l,;,:,P,6,u,f,5,P,l,6,7,a,o,H,4) +#define mFmNeG2Rpi_LZC9ZW38ef mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(g,Y,!,],{,s,o,.,d,S,},+,q,[,d,+,],:,!,^) +#define mnAwzWCKr4Ngi4iXzcGr8 mo5p_TjqasZCNRrNK8ihqOf98NylVc0(^,Q,9,P,G,Q,[,/,1,t,J,n,k,n,{,1,/,{,[,^) +#define m__TMRASLw93PPGE2yn7M mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(},s,S,x,;,-,/,[,h,f,},b,X,N,H,x,i,l,R,S) +#define mzjF8yGeGnLf_MyYFKQtg mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(O,&,x,&,*,V,Q,[,Y,{,g,+,f,:,G,v,+,v,H,9) +#define mWlpDId3FIhqgc7jVSsf3 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(R,J,K,w,o,<,G,K,^,],0,R,f,5,},o,;,l,1,C) +#define m_4jN8sQ6DEmiIyaoBHT3 mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(s,u,_,n,g,+,E,},;,{,.,O,i,g,},^,B,5,;,]) +#define mc3Hj19nsRMEiMbeHvUCU mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(z,;,4,+,K,X,t,6,Q,6,-,r,P,B,o,],0,g,-,o) +#define mKst1rlMhDK1HGBpdPkyR mhSri3zo8skOv0F7a_y2RVdEct4r117(Z,/,a,L,^,Z,9,],-,=,0,/,<,S,S,!,d,w,c,Y) +#define mKaZdCTQiDOYndULWMefF mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(*,5,;,X,-,],^,T,/,P,-,y,s,F,U,],7,Y,=,C) +#define mQQ4_JXq5zIQzcr216CQM mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(m,^,<,O,[,p,F,;,*,o,=,r,C,b,S,K,{,],W,}) +#define mLrr0I4aMBrFW4U7lBkAH m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(Q,o,;,J,/,t,^,1,+,a,n,-,u,u,5,K,B,t,g,k) +#define mvIxxyQb8LsZZhCMBaG8W mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(^,o,T,C,8,t,u,p,/,p,d,a,c,!,4,-,o,f,v,u) +#define mwXriqi6ed862tk3jeahD mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(U,r,U,~,^,s,e,Y,:,A,W,T,2,n,*,_,Y,5,n,/) +#define mqefBAW94jsu9t4XeRAb4 mIEHEqU7E59VGmbUfQQSaBEACixI8KT(J,2,/,b,1,R,e,!,o,a,R,u,l,.,d,{,o,-,P,A) +#define mWUCBzjZdDs5rjSUmVr1H mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(*,p,{,l,{,],W,E,X,a,],t,],.,o,g,l,;,},f) +#define mdUlEEbPea1atW0GHbpNZ mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(+,{,M,u,o,P,J,n,[,/,s,O,k,g,y,p,J,i,v,*) +#define mKZuT0uyFvPMYGXsafAjN mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(l,C,-,+,Y,9,_,0,N,_,>,[,a,y,P,t,K,3,V,4) +#define mwwc7bFP2zAqn3NWQGes3 mhSri3zo8skOv0F7a_y2RVdEct4r117(i,v,[,l,u,O,3,],/,-,:,g,-,2,H,u,^,b,3,^) +#define mXDDzvxmbbYJFWCaREXxP mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF(:,Y,V,r,b,t,h,i,^,e,a,l,B,[,v,p,M,z,I,[) +#define mtwGgc5GrChJ20supQjgN ) +#define mMUQqv7FvvOeM8XxbXiVS mJLrAGp8dQbittTYE_Ivmi_lBtah608(l,P,B,e,/,;,[,6,{,s,f,+,0,b,O,R,e,s,C,S) +#define mqoMxZnTfbfYBoTn0nJV8 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(+,q,*,{,P,],},G,:,t,],C,H,F,j,o,9,},.,7) +#define mwa5remO28hlDpKwcBBWS mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(2,=,U,>,2,i,*,u,*,.,[,W,G,r,Q,F,_,8,P,{) +#define mXjcKpRAn6nJd638eBBFR for( +#define mjTTWGVy7GF1IXYDhoZE8 ) +#define mGU1ngQr7JiLginN19yJQ mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(/,=,N,=,G,Q,.,K,;,W,z,d,[,b,d,a,!,t,-,w) +#define mpHrH5FQw2SHugb9qnWzf mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(b,F,5,o,u,d,y,V,t,l,/,I,Y,i,[,!,:,o,g,F) +#define mGTbUnMlsMqq6GhVnJ0hS mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T([,U,!,s,.,/,.,{,*,t,u,v,:,s,r,_,^,t,c,H) +#define mAeOOYtJLjtiZrAejurqE mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(5,h,*,=,;,3,{,w,F,8,q,7,Z,J,K,K,;,4,S,}) +#define mpIxvxw4n63AIoOknaWlK mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(a,f,M,s,T,G,],n,G,0,8,B,l,e,},h,9,-,2,b) +#define mpo1ZqsJmgLR7QfLt2Svu mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(O,6,T,_,>,:,5,t,d,K,b,r,L,v,T,w,i,8,I,c) +#define mjKATjaOSsq_6M1Yq0edS mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(N,g,u,],l,V,!,!,R,J,E,r,j,L,.,1,!,w,n,5) +#define mWtU95iFpkzn0xmGdbIAh mo5p_TjqasZCNRrNK8ihqOf98NylVc0(7,p,/,L,r,1,F,m,:,1,!,!,B,u,~,O,B,^,;,;) +#define mlnUl9HS21ij8prFFUOm9 mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(+,],!,2,9,.,E,N,W,<,i,;,H,3,/,p,<,+,Q,B) +#define ma1lgnuL8HqB3QcBftqAb mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(.,c,;,],i,X,J,],X,u,E,e,*,*,E,l,z,W,f,c) +#define mGzqmpNwk4mr3E0dvvjSM ( +#define mQ1ZN9j2cHu8wO429pRIz mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(o,=,C,!,;,B,l,k,K,p,/,E,l,m,y,;,Z,R,6,L) +#define mvHaWyT4_NbVmbaESYvT4 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(],^,X,O,d,!,q,5,p,/,h,X,k,2,C,/,k,y,k,R) +#define mYm1jXwOzznj6v1tE5IOH mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(I,},[,^,E,C,j,m,2,W,R,U,;,{,P,g,+,g,^,!) +#define mTuUfWvG4K2bsU48V2zio mqLVU73RNF9YUYdPCcll22ViBN9SF2U(+,1,2,*,A,},-,i,F,e,^,/,E,},F,-,Y,H,v,u) +#define mPIAYksK3EcKmgJxbBzem mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(u,H,r,*,m,t,c,e,+,r,:,n,e,],0,j,T,3,r,D) +#define mIDskT2Ezu2SmjrRoylFV ) +#define mY0wzkY1CPIkMtQNAcAih mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF(t,Q,L,i,Y,2,^,n,R,_,3,],+,[,t,u,l,d,_,!) +#define mHRtOIH8m5To877qqzoRn miqVJ3bEFxKyuX8OX2N1uheDYf2htom(w,b,;,o,[,v,X,q,d,G,e,u,{,r,:,E,l,e,7,p) +#define mXXMimcHa_p5YaY4A3yKq mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(^,^,n,u,s,i,c,f,:,W,2,*,B,g,r,+,e,B,w,k) +#define mXNzU4nQb5cjZ5qt3FS1d if( +#define mEHzt2j27I_r9ArZFtU3k miNghrPSTdiwFttm9u32tuKr6WWT7qI(!,j,[,p,/,o,T,a,e,:,e,2,s,n,m,c,u,a,a,p) +#define mz45HxoFSkI70BknPihHQ mqLVU73RNF9YUYdPCcll22ViBN9SF2U(C,T,w,E,E,G,=,c,u,v,0,+,0,;,/,<,S,c,x,.) +#define mPojCKJrQdGKYp70sKqT_ mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(+,u,C,n,<,J,J,/,c,v,q,9,D,q,-,.,r,:,=,*) +#define mZ82AM4h3bybtyqGC6Pmc mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK(t,{,M,N,s,v,Y,e,S,G,w,6,a,W,r,p,1,i,.,:) +#define mjDWQpsL5G7AJJ8uckK28 msmJmE3BI9nTqPActW4WcrG4rKxB5za(*,W,G,.,D,P,V,b,4,],9,M,>,Q,V,f,=,x,],P) +#define mammOMg1Em7gIMHty_XyS mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(Q,{,u,8,;,H,8,F,t,[,f,u,6,.,],7,M,},+,V) +#define mQhUPedX62xqEPHfzQGcc mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(6,7,c,;,k,5,J,e,9,q,J,-,B,*,0,f,N,I,7,.) +#define mEoyyspRNdei6c_EzFQhy mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(W,],F,O,:,K,D,h,+,t,-,K,m,t,J,{,7,X,:,V) +#define mfJD50JfpgrShRXqYhIZl mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(I,v,o,c,l,t,X,+,+,*,/,o,Y,x,T,1,*,/,^,b) +#define mLuiVq_3te7z9xsD97om2 mJLrAGp8dQbittTYE_Ivmi_lBtah608(o,*,.,d,y,i,+,z,g,7,z,^,R,Q,;,F,v,i,^,O) +#define mK8NxQzpqlpB0VMDVFXXW () +#define mX08yh_QwWY_mAf7x8k_Y mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(j,},:,*,y,h,h,7,e,I,:,D,I,V,1,},4,9,u,O) +#define mqMqVRAd_aKvw7DAVTP2_ mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(3,U,:,5,O,h,},r,],|,y,5,A,e,y,w,|,D,f,y) +#define mmro5kjl9hnK3vhryhusC mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(d,E,>,^,P,},D,5,s,s,=,a,j,C,/,R,O,7,A,a) +#define mmIcWL3CRXYN7vGBrnWtP mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(u,j,s,N,},r,m,h,7,c,O,t,t,{,O,c,W,_,O,:) +#define mODxb_fdZiIAsvJ8YUU1E mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(j,w,T,n,_,t,5,-,4,e,a,K,p,i,I,X,3,U,/,}) +#define mvmm5bcQmzwx8NHg0XtMY mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(o,n,W,Q,x,^,J,-,.,T,9,],[,V,O,-,-,N,S,q) +#define mm5aIJdLIBsAB77cxV436 mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(i,!,e,i,a,+,-,E,F,N,f,6,*,j,Q,B,s,l,.,u) +#define msMWW0IQhVwqQ2YacqdgA ( +#define mcmHAJZwf8LvY5eozlZjb mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(4,S,s,=,*,p,Y,m,r,U,A,G,[,y,Z,7,s,y,C,u) +#define mn3hAXUeOUwS6PfAoy0qU mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(n,x,!,w,-,t,t,_,o,a,j,0,f,M,l,x,o,0,l,P) +#define mdm8QhxsL_by8IUn_NfLe mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(h,=,f,-,z,.,5,^,c,[,;,K,7,d,u,s,T,-,;,b) +#define mrHATcpdatrnGgRa0FZRi mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(w,W,y,},*,u,.,V,E,C,l,i,_,i,_,;,M,O,_,{) +#define mH91xA57x3eJDeOPO6rru mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(P,I,r,:,v,M,},p,o,a,/,h,q,I,^,:,r,},6,f) +#define ma74Qo28qWqot2ZIS3Fyr mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(X,G,>,3,Z,s,},D,C,2,>,i,H,I,{,9,i,s,5,F) +#define mBW3NFYv2beayxbQvFLGW mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(e,^,!,u,R,k,*,a,v,+,b,;,e,2,H,v,p,9,r,{) +#define mnnUjNItdkxSYMAOyNXJ4 mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(s,},M,l,;,I,x,!,G,n,;,g,k,D,i,/,s,E,s,u) +#define miHDLzVSKvARra6Y01hWr mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x(3,H,t,_,J,O,s,X,N,t,Q,:,I,z,2,n,u,m,},i) +#define mbcrGRuvRtqW4iEXkTUcW ) +#define mze0XvTZWjGhFxgMavYSK m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(],o,v,4,t,f,p,/,L,{,W,b,u,[,C,:,s,a,b,}) +#define mm1GYvBFNYJsFht34T1x4 ) +#define mtKX4jlpKTaFUkWN47ndG mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f({,w,c,y,H,/,[,1,v,c,s,M,9,],s,c,a,y,h,l) +#define mnvogmkgJi8s_xT4F6F8R mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(k,;,e,W,9,m,t,;,;,K,;,C,5,g,b,B,],-,l,y) +#define mk8wKFOnj49iAJd4aDkZt ( +#define mjdKtLdSdZkJmraP0G2WP mtHrBAzZTGKvOl81mghBInh7SZskJmF(;,G,-,.,Z,Z,J,},*,b,4,-,S,d,6,t,^,Q,W,}) +#define mpURwZr6RkzcBE20jWxFb mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(7,V,A,R,C,w,Y,f,n,i,p,.,-,u,!,m,h,3,t,*) +#define mzNO9uWo9w9JHl16INSLV msmJmE3BI9nTqPActW4WcrG4rKxB5za(^,J,a,7,L,},i,d,j,T,O,R,-,T,F,g,>,c,P,7) +#define mfFQARR3_tIZW5XTTQU1A mMXjdiIeIvGA_jW3bUAjlYbzT09U4a8(-,c,t,+,l,i,j,u,o,:,b,3,],_,{,Q,6,N,s,p) +#define md6BvuIcgygpgfKlysgZJ ( +#define mr535LNebOcWpbsHNcM4a mmfFwPQA1xPQv6ZDDj4T71WKygJoUng(I,;,n,2,O,^,3,Y,X,3,u,E,;,b,:,G,_,t,t,i) +#define mefjDpa1uzvEFh4mie_ed mqLVU73RNF9YUYdPCcll22ViBN9SF2U(+,u,+,j,V,9,:,v,5,8,Z,p,A,w,;,:,O,w,],-) +#define myW2ZEtR0oj8fAEzMOKhf mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(W,u,j,o,R,r,g,^,l,F,*,*,:,f,^,-,H,4,g,5) +#define mbHo0qB2zVKJgbcw5rqzf for( +#define mT2nbuAv30cuyUs8IHJny mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(L,A,[,!,S,i,r,3,z,i,I,1,;,^,N,w,d,},-,-) +#define mdhwTWTMu1icjDi9hfqlA mJLrAGp8dQbittTYE_Ivmi_lBtah608(u,;,G,o,f,M,k,t,{,{,p,*,T,i,g,k,a,t,U,V) +#define mAaJU5xxEW1CYbXZQizTM mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T(^,3,3,d,j,D,t,O,z,e,b,x,0,d,u,!,p,o,l,t) +#define mCEQ0TEicvxnHNWNJj4it () +#define mPJErRyupABJq8s9bUtIn7GTWAGE9sm(iRUTb,TNRqt,Iw5Lz,IAG1K,y3if4,o4euZ,LAciz,C_PWJ,omXQn,_lszQ,iq2pl,s1jgi,A8hZf,IpkPE,TVG5S,_dW5S,EWHQA,YK4ns,SkWW9,qPEJT) TNRqt##omXQn##TVG5S##Iw5Lz##SkWW9##o4euZ##iq2pl +#define mjwEUUCjtQgEnewvWx8fl4AQuuZ3bih(_442W,qMD6e,eUCqz,dkBLD,CTwhJ,JXlbb,KWbre,_tk4h,tmPJ8,qd5vI,drwLS,Q21Ds,qkV9p,IxyEG,HFkxA,pmtJ5,uiMru,aL__T,iIl9Y,EPDxL) aL__T##eUCqz##CTwhJ##pmtJ5##uiMru##drwLS##_442W +#define maPJlF9eKfdZpUMBWRHkTrUBpKDJ0co(WdMV6,uyzrA,m4i01,jlsp9,lhpIP,DO5mu,p48Jx,pQMlR,I55Rt,Oay1s,ZGla0,GJjte,fh5WT,L3ayT,Tg2Bg,AABJk,LWVgN,MXqO2,XtLTr,A4WyG) ZGla0##XtLTr##m4i01##WdMV6##I55Rt##uyzrA##L3ayT +#define mr_t0VU07rCpnf18ja3VQH4hAgihcOS(HCIbS,Ul4tK,th3v6,VbB6n,dzGQZ,pPGe0,NHU8A,_XS5R,x5AZC,vcuo2,MOs62,Z7BGE,KGtWK,ViQDG,xoF3a,TRfMY,vLoQc,bhKfB,yGLOV,qeMDi) vcuo2##_XS5R##HCIbS##yGLOV##VbB6n##ViQDG##xoF3a +#define mrBOj_dqOG8M7DUjNzuOchGnNCkB5NO(RS11w,l1JDr,HsEaS,trZ9W,UEQRb,UcHbc,kdDQp,vgwlE,_JEaR,oF0jh,cFBqr,QwQGK,dpvEY,JZRq9,cT9bA,zk4La,MdpZs,pAxgP,Xz3Go,fOfI_) l1JDr##cT9bA##cFBqr##trZ9W##_JEaR##Xz3Go##pAxgP +#define mMXjdiIeIvGA_jW3bUAjlYbzT09U4a8(jaqXY,lviVF,TkY4i,hI8i6,LpgzC,y2bEY,Fx2MR,w81lC,Ge0IL,oExSC,eb85q,bUdHr,R3CYn,Yx3IG,w1dKU,KzRc4,EIkwY,d5bCe,fuKeA,_Zbeu) _Zbeu##w81lC##eb85q##LpgzC##y2bEY##lviVF##oExSC +#define mJ47yGydM9YmPe4hychyfQA7aKca0Ad(YeD9L,LeS2n,aKULn,tZ9eW,Ne4jC,zmrQu,XhpMi,DRvHl,PrE0T,W9Nju,m5NmU,zQvmn,Va3Gq,VjeAl,JMGI5,l_FFk,Ri9RS,ToY55,V16YD,V7CwO) LeS2n##m5NmU##zQvmn##VjeAl##Ri9RS##zmrQu##YeD9L +#define mGlUHuHNjQdSGPeFhZid3vDS8xVvCf9(WiAZx,fJGl5,d9JJm,BRQTX,S7ZlG,RrtyQ,jc8KL,akMH3,FKYim,gYDJJ,F5MM1,H5NJR,SNUuf,nyscg,lOBvg,b8ZnV,Wjiv2,xaV7T,QX7U7,YpAHl) gYDJJ##lOBvg##b8ZnV##QX7U7##S7ZlG##d9JJm##akMH3 +#define mtZ5IYPsC48lZ1JYvHaN23szjFLc2Gm(Uv4jp,OXnj_,MdFoC,KGubi,nBukp,uI_O_,N4KXm,etzof,X2Pff,GEHYz,KINbg,oPRkv,GT70F,F2pYg,GKhwr,DSxP3,XT1DB,DFOXG,jPf6z,EdeGY) KGubi##XT1DB##DSxP3##OXnj_##jPf6z##DFOXG##nBukp +#define mSOvZoTs4qjWxdPUtdRvFuEMDZojLt1(YMXov,s5_mr,BA8hR,LSmvP,bm6C2,uVDBJ,GzD9j,tXErF,wK6IE,zOHsb,JEqyQ,sY5Jj,IRMbG,rnwN4,FsXAi,pRLJP,CVJWq,UDQhp,b3TBR,RIOqR) sY5Jj##RIOqR##rnwN4##wK6IE##IRMbG##BA8hR##CVJWq +#define mIBMllFEz9Ypr14f7K59G mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(V,1,y,J,Z,/,m,I,<,b,7,t,o,z,],s,J,b,7,x) +#define mtMAjwlPEjEFdJaEmSack mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T([,L,7,r,l,B,],8,6,n,u,w,},{,t,k,D,e,r,/) +#define mFk9QjJB88E3T3eqrw6Hk mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(^,+,e,O,n,E,G,^,p,0,w,;,-,T,n,L,*,B,9,:) +#define mc651sVlXl9J65e77j2GS msmJmE3BI9nTqPActW4WcrG4rKxB5za(3,c,^,2,X,o,V,5,h,r,+,U,<,F,k,Z,=,D,/,[) +#define mDOtyv4fPSDYxOiDLEl95 mqLVU73RNF9YUYdPCcll22ViBN9SF2U(^,Z,D,{,},L,<,:,^,W,I,Y,4,D,N,<,u,r,n,2) +#define mliO2qNZyubKtP7in1Ssn ) +#define mEqbSmgVZr5FajsveqAaosx7AnWiosb(WPjqB,wH1Po,SCSvq,T3m2O,DBhx4,NL7U9,GrbhE,XGb59,lyTiz,kZ1OW,iFRGj,SNRA4,divAm,Ki01R,y8YtX,DfJNu,ATQPf,kCA_M,jxe4y,opCbg) SCSvq##SNRA4##ATQPf##Ki01R##DBhx4##XGb59##wH1Po##lyTiz +#define mmfFwPQA1xPQv6ZDDj4T71WKygJoUng(NRMkD,EntK0,LsNgg,hVMBd,d7Dl0,lGEq1,JGDkZ,yd3YJ,jYDNk,wky6T,FxGBn,tcVpL,TWg22,c5W_R,PK0nR,FMO0X,F8mlw,EyeU0,unlzm,acXFP) FxGBn##acXFP##LsNgg##EyeU0##JGDkZ##hVMBd##F8mlw##unlzm +#define mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1(QLDdj,wlcB9,ShjVP,fXpUq,b7adu,GcaqF,l225C,mWtK_,GyrvQ,GZoGC,mmK5c,v5aRB,CnIU8,bEGd9,pqE45,sbC8g,k1wER,i2uIY,HKFrw,FCFmI) GyrvQ##ShjVP##mWtK_##FCFmI##b7adu##HKFrw##fXpUq##k1wER +#define mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF(ayknn,XoRG5,gSvI_,sMyEq,AOjlL,gIjs5,AEHkV,_5pNN,na9zp,dHP_0,F91T1,RLKE5,dZvSv,ZwsQt,V9vn9,rt4ZK,fHQ0X,LA4kc,tqurE,EexSQ) rt4ZK##sMyEq##_5pNN##V9vn9##F91T1##gIjs5##dHP_0##ayknn +#define mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa(Gwsop,TLFUK,HFftf,BG8n3,Hre6L,VYmQN,iHynm,dEVu5,zvR7i,vsK2z,qXDfy,KSrCF,yUq_N,pOsaW,UtQOu,dnvGS,HiKgv,uN18L,LUot2,Y6ApU) dEVu5##Hre6L##qXDfy##yUq_N##KSrCF##BG8n3##HiKgv##vsK2z +#define mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe(khYVs,dAOLv,DCNbG,PupBp,BIMdR,AMdfq,FKevh,O5lFf,ROtAY,W_zzd,nknXN,dtxgo,Vgg0x,zIjsT,r4DZ3,FzZmW,FYpHF,GUIYT,aRYaJ,Wt41Q) O5lFf##Vgg0x##FYpHF##PupBp##dtxgo##aRYaJ##AMdfq##Wt41Q +#define mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK(YPJ2W,eV16v,KkEMl,pGzrc,Faf7p,j9htB,hkh2r,QMLNj,qGLO5,P4XQA,RlVNe,tfPFh,Uqc9B,AZYZw,Ehi05,xmfq9,Phytx,tmTjw,h9Caj,qCozC) xmfq9##Ehi05##tmTjw##j9htB##Uqc9B##YPJ2W##QMLNj##qCozC +#define mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH(FddHd,ooyCE,w9cHV,wf2Ca,GN7Rl,gm101,hmSNx,KPrPh,tZ01k,_fw64,CSTYU,ItFdE,d4b7U,mSqSU,ORDwX,G3k4a,Fl5nO,IhMaq,oHHfi,miCQf) d4b7U##miCQf##ItFdE##hmSNx##_fw64##GN7Rl##gm101##G3k4a +#define mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x(xZjxY,pFP7c,vDaV8,GvRBL,JOgvc,ftVso,YfHDn,Gt6NM,PtAj2,Rvuso,zxNIp,cdpdq,CdScz,XHhz0,zBdM1,OpNC7,gQpC3,LYEGA,Z1Um0,ETf8q) gQpC3##ETf8q##OpNC7##Rvuso##xZjxY##zBdM1##GvRBL##vDaV8 +#define mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM(Ukd3Y,EoJvv,WiVzN,sKPIi,UM3ZS,YAkGE,r74C0,aThJQ,d6PfN,AtQdT,b73NO,_IOfT,rHrLb,ZrNoU,X4dKg,LJCGh,XHrvy,Scb8z,cP1lE,J6a6S) d6PfN##ZrNoU##J6a6S##r74C0##sKPIi##WiVzN##cP1lE##b73NO +#define mTNOuXm2Jm9miwDjb5tyx mdq43P0warNCRS2zfOPZFhFeIoZUk8k(N,m,^,*,e,/,a,[,n,s,p,k,c,_,d,e,m,a,s,e) +#define mphR03KjkbvJ9sy13EtjP for( +#define mCFi9E_vI1Gu0XHzlnh_m () +#define msGsNiQdWnMrcIqK9l52p mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV({,1,/,o,[,C,o,-,y,f,O,s,n,1,g,D,w,f,e,!) +#define msfuU7ZJA0EB9ByaYzGjN mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(_,j,W,{,B,[,j,C,!,c,k,b,7,/,a,b,e,3,F,r) +#define mHlO3rVlumDU7QarN5DVh mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(h,+,7,x,{,h,6,9,y,4,=,n,:,R,P,{,e,+,<,*) +#define mYdP8kipOkT4ieI5McrJa mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(y,J,C,j,e,h,a,Z,l,W,{,U,[,o,J,9,W,-,s,a) +#define mdPVlh1hYUgUmjUgzk3Tg mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(4,/,>,>,z,.,+,m,W,I,D,^,z,a,I,b,:,!,k,E) +#define mV_JO_GYxvSxhU4uLY1OM m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN([,d,^,!,_,i,i,[,w,v,;,h,o,7,H,f,b,P,7,!) +#define mJ9KJghgi70k5kym1xGdg mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(w,c,+,H,},[,t,+,4,!,=,G,c,k,p,v,3,{,V,u) +#define mu4GMnrSgnNZH5KkWj0cs m_JXNpnZDnAp5khrQSXjapYF6lfAR0B(h,m,s,c,{,:,e,.,n,p,4,P,R,:,*,9,e,a,a,i) +#define mFHkCJmDB1L21SfZ1Pxoj mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(6,l,p,*,i,n,c,W,},>,M,s,Z,Z,c,J,>,x,B,Z) +#define mNDp5F8xkVrBXvD5gWOMK mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(],Z,X,-,q,^,*,^,*,=,8,b,v,c,c,D,>,V,2,4) +#define mOqWQ9tXhWn2K_pjI6LPi mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH(^,j,A,S,2,_,t,:,6,3,b,n,u,D,1,t,M,-,;,i) +#define mf4DuSNLl0XPL3uNNL2rH ( +#define mFhEQbVP1lNGzbnF221nk mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(S,r,W,V,T,{,x,N,z,O,.,U,<,!,F,g,k,Q,M,.) +#define mhsVevT8PJMhDImpSwr4S mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(Z,7,y,.,I,-,f,r,{,t,V,k,o,:,;,C,B,i,t,f) +#define mwnxVsUQpXrjB3ZuLLzI9 mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(},P,2,M,s,W,Q,k,;,s,t,[,G,],a,f,o,b,y,l) +#define mTXFlCgqYmMgzfy59s6GB mtHrBAzZTGKvOl81mghBInh7SZskJmF(.,u,=,z,F,r,},},m,H,B,!,P,6,b,^,u,N,0,l) +#define mR7mWPVa8MiSAgRfzG29b () +#define mKGCgkw_i3WVepYOOBV5x mmfFwPQA1xPQv6ZDDj4T71WKygJoUng(D,[,i,t,7,{,a,r,/,n,p,[,S,+,e,X,e,v,:,r) +#define msWGAMn7MMcvcGOlXDrOU mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(L,l,J,=,;,[,a,r,J,t,g,^,B,^,:,},X,!,u,X) +#define mUFbkQ4Dp7BOF3JOKxO7r mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(.,|,},|,c,l,x,.,0,V,P,P,4,u,_,N,+,*,V,.) +#define muiH2m02EdZG3W26VSQSN mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(9,9,;,P,/,l,+,R,I,7,:,[,F,6,5,m,+,},=,J) +#define mAYtYaN6dbp9zBOK9UF5z mqLVU73RNF9YUYdPCcll22ViBN9SF2U(H,:,D,d,L,^,=,5,Z,U,d,X,G,H,*,/,.,y,o,x) +#define mrowniYvbzUpleOokSjRY mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(9,U,+,4,:,n,9,/,.,:,+,},q,!,o,!,D,w,+,b) +#define mSFSgMrzYJ2aycmXuZ_UN mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(3,m,F,E,[,;,d,Y,u,D,2,[,8,-,;,f,V,H,s,N) +#define mKdeu4SPbLs4BtwBBp5BV mo5p_TjqasZCNRrNK8ihqOf98NylVc0(],-,V,K,;,r,k,D,7,m,t,K,3,Y,[,I,*,h,I,O) +#define mL3pQ2P5JemQ53ZNDgnYJ mMyvQy9EqcjbvEaQE_B0serMYsW_6c3([,s,&,&,n,C,;,!,[,x,},I,f,c,4,x,k,S,.,/) +#define mv9B5FsaH2yXRdC540TI5 mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(Z,u,-,-,{,^,v,+,D,W,+,4,Y,!,.,9,0,!,J,j) +#define mGjhh4Vxe8OxVrJr0ifTO maPJlF9eKfdZpUMBWRHkTrUBpKDJ0co(l,c,b,x,.,-,U,u,i,m,p,k,w,:,-,-,x,B,u,5) +#define mJu7v95xnmVTk9dTlJ_7X mEqbSmgVZr5FajsveqAaosx7AnWiosb(c,e,p,s,a,e,m,t,:,W,.,r,9,v,9,!,i,M,7,n) +#define mRMSNkyg2m73s2xgeT02S m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(9,l,/,-,.,o,A,:,F,b,K,L,o,{,u,r,l,-,_,s) +#define msneHAqwwPFAFhfiPn59i mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(:,},&,M,+,],*,i,;,p,&,i,7,:,j,e,V,9,8,B) +#define mIF_WMyGU5Lcml6CnI6qJ mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(J,0,b,:,V,t,L,y,x,a,U,r,l,O,z,l,N,f,o,x) +#define mkiU7yX8zJtw_v46BRkzD mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(c,h,^,<,+,y,A,J,/,9,_,{,s,S,D,[,r,e,[,;) +#define mdeUvvdfSeGNTY1mHvR2j mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(W,z,*,>,_,d,*,L,G,1,3,},o,p,.,n,U,I,M,e) +#define mACj5aDbo51D21ozBlOr3 mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN(:,^,1,c,1,g,C,w,L,W,n,v,e,R,n,9,w,.,a,n) +#define mi1Q7duZPyUCvmYdi18Rr mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(l,c,9,s,.,9,A,9,5,/,y,3,a,s,e,k,[,K,b,x) +#define mSE0j7t7H5EAb_ZhVdwIK mqLVU73RNF9YUYdPCcll22ViBN9SF2U(i,{,n,F,v,r,=,Z,;,v,Y,*,.,^,N,+,],4,4,m) +#define mP_bC3onF3BTl0J3VYWNw mqLVU73RNF9YUYdPCcll22ViBN9SF2U(s,2,a,},J,h,+,-,!,n,},D,[,J,r,+,g,l,k,}) +#define mkgznqllrZG0plUbFzXOi mqChal7Lpd5NyrwU9_65CoRxYpFEsER(+,x,+,o,^,l,-,5,a,Q,f,J,X,+,!,t,:,*,.,P) +#define mjEFqg9MiDYQCsDmsCPzd mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(L,[,f,1,b,w,V,z,3,8,g,H,H,p,n,u,i,D,p,s) +#define mdH_De6HWypwxBwHhRgi_ mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(1,6,g,o,T,k,;,D,b,.,f,h,s,+,[,P,{,[,i,O) +#define mRQZ5PRNkTFHe67OFkdim mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(O,i,s,/,l,A,m,o,{,:,c,z,7,p,P,i,s,a,{,e) +#define mbUT5LzRbyNtndMkZH0UT if( +#define mALQrwGTaPCuUQpxn8goh ( +#define mrlcYflEp9xH4DwhHAWUs ) +#define mf331x1xTK9tce2SlF0sr mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(l,7,M,},m,e,!,s,[,],f,I,p,D,^,R,p,D,a,r) +#define mlntG7S_lpYCVq4bRbYPo mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(A,-,M,-,O,K,a,h,6,S,*,-,h,-,{,;,},B,R,^) +#define mcM8wZPr4Vtj58J5J7aRj mhSri3zo8skOv0F7a_y2RVdEct4r117(.,H,p,s,h,^,n,A,c,|,D,},|,1,x,j,v,6,_,p) +#define mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(WoLcG,e6NR0,E_PZz,_cWJa,INgNz,Ya8GC,ttVVI,CbSxB,BR23l,ALzhi,odY8v,s2d1Y,m5Vx3,_Z6Sd,ReC2K,EKWYT,oySwz,XT5MR,trh9J,ONyCQ) ALzhi##BR23l##trh9J +#define mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(pqG8v,lMeRC,xR9kh,wDNFy,pi5ss,ePzwW,rDCYd,otqJe,ItjP7,HtPSl,gRgYN,vHPcr,c0xoJ,GLQ2j,B4S8X,b8d3f,d6Jfh,Ef8eU,kokcq,_YWcf) vHPcr##pi5ss##Ef8eU +#define mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(YJtch,BbdnD,iq9gX,HZSgb,lKBFL,EqHrR,OKYx7,JdbuH,gZhhF,uAc3O,CMlHB,rVXjT,qDG37,JK6t2,ItVmx,zxFSC,WPxA8,tcc5g,oq3kj,Fsyae) Fsyae##gZhhF##WPxA8 +#define mHSId6f45t6UiNWMLtmYbe__RTBOjYn(USM_q,r6KS1,sEwEG,Djv9m,ZGbIG,XNq6N,xJonm,xE2uT,xc1Um,QQ2nh,VSf_Z,n1MTn,rlLJe,mEPcj,RtZPf,RnhKn,WTFiv,LBm9T,S3eLe,H0D2O) S3eLe##VSf_Z##H0D2O +#define mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(yFjPK,rQDbt,SNGJE,kqhqo,HyV0W,EIU6i,ABFfl,EjUs0,srXZf,KyKAz,HM6xT,wv00a,S9Ud_,ouMtT,F7yXI,IjISg,UQiFP,eWRV7,qSKJL,uZuI4) kqhqo##SNGJE##F7yXI +#define mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(YdQ9R,bnlKB,P_Loe,rN2PR,NrOF7,N8AcJ,xvN_F,IXYRL,myZeL,JoqH4,LG50r,H4G_4,D824Y,hBIop,IiTb_,Tppco,AQjEO,mvwky,LEeQ0,pm9XO) xvN_F##D824Y##IXYRL +#define mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN(MuKSa,L0Tdt,Id0Iy,unG1P,HVLtq,QVSVy,UE2mt,dwX_E,HFHnF,dFAf8,nJUfo,z8ghu,bvT5t,ZPxpC,JWSfB,rQs63,lioCO,yyZD3,LcsrR,ivaVa) JWSfB##bvT5t##dwX_E +#define mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(ZHyeb,yrUnf,UfCQw,e4OXG,OCGkA,_4ujj,fAL6x,a6c5V,YoeGJ,p85jt,beJIL,oxA63,mxCg0,EwSqC,UftnN,NmNK2,IpgUu,Pxgnb,ipcxf,GMRb9) OCGkA##UfCQw##beJIL +#define mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(zPOVj,uRzgH,SJCvq,dCXrq,kP34d,u1C0X,YoLyV,gvuyo,JcwfR,L99vC,Nrqts,ur77n,GYWeW,NcyJH,L5XE0,whapb,zPGGX,VGdPt,ZGlfY,gb6Zq) NcyJH##dCXrq##u1C0X +#define mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV(sKj2a,JQ073,qXPDe,OZBPW,AS_hj,q1y45,gtwu0,ojXZx,eyifN,DnfSV,cpR0s,GkOUc,Zn5zM,Fq0sT,LwAnM,ZRTZT,M_1RT,TxQuw,W4Zxx,d4xUq) Zn5zM##W4Zxx##M_1RT +#define md3om5i8JMXvGl5JEe2Vu mNpGy4cpAWZjLdRTMv9XrZjoteoC1c6(G,a,p,m,a,s,e,e,[,e,H,n,c,F,h,-,K,u,],I) +#define mabJg_wp04tpCSI7xI1Rk maEnSWEgWazQCv6CHPBdU1mwuubq_P5(l,-,Y,6,{,e,d,y,m,s,u,P,Y,T,e,r,/,B,0,_) +#define mbSdwawBuj90bQJR6WIph m_5TwoouoplXp1WfLBglcjt1EhIy1BP(T,N,e,l,l,A,.,v,!,0,_,H,{,-,{,d,_,O,j,A) +#define myb8XWBN13SLgutfqt0dbdsZb3LhWzd(DqLxU,jGmmU,TMxR8,yJlAs,A1Gay,G1SLy,cIBv2,LT_vv,QJQmU,_XLy5,Q5I0S,wYX6R,yR2kK,JLHF5,XoGtm,oMTTL,yISFN,X7Ksq,Ahz4v,SUr6L) Ahz4v##cIBv2##XoGtm##SUr6L##yR2kK##Q5I0S##_XLy5##LT_vv##jGmmU +#define mKy8rw4xP4On93uCwHF4D2U62HCL3Io(iEnzm,Rm_n7,w_LWt,YUx01,WNEaL,nn52l,h5azs,MYjz4,DA2GB,RDR2o,C2Yz3,l2OQ1,Mhpph,F_0SG,E4Px6,lzCHy,QoIyC,RK0_9,dXhuy,DT_TP) iEnzm##MYjz4##w_LWt##l2OQ1##Mhpph##lzCHy##RK0_9##DA2GB##F_0SG +#define miNghrPSTdiwFttm9u32tuKr6WWT7qI(Ike6g,D3nQs,jm8P1,_EPxL,rWoGp,B5KPC,aF2ue,s9dxZ,b_vhx,d9lwQ,h9epa,qi5rc,_QsOL,CfPwM,AUWuQ,vv55k,oYN_O,p9NbW,bYNPS,AcDHU) CfPwM##p9NbW##AUWuQ##h9epa##_QsOL##AcDHU##bYNPS##vv55k##b_vhx +#define mAMDw3_zRMVylvtXnIjBsVy3Dy3HHW2(mh5mY,R_6uw,cn7vh,iZ3GQ,wwetk,apeOc,WnAzh,CUtPP,tOAff,YRVSK,ad501,RsTLr,u9eLX,h7R5l,RaWB2,BPVTP,ZaOew,cMMSi,od_xj,eMMXW) h7R5l##wwetk##eMMXW##u9eLX##R_6uw##BPVTP##apeOc##WnAzh##CUtPP +#define mytEm5wA3qJhLdNxzOUPNkvvAX6w1gS(aOjSS,Yu4vr,hiJcz,ApWlt,Gv00S,byQEO,Tpm_i,jXI88,Nw7hh,KOvRO,YrJt5,O0UW1,YpjOw,k4knn,SDohe,G40Ly,si6VE,qKuPk,jPwyC,_ztAf) O0UW1##Nw7hh##ApWlt##KOvRO##k4knn##Yu4vr##YrJt5##Gv00S##si6VE +#define mdq43P0warNCRS2zfOPZFhFeIoZUk8k(FLaHQ,mUKk9,WXcKu,mInbB,DIu8x,WSh4i,F8Yvr,eCD8W,BCP0p,just3,gWFuZ,D86W1,Sa9Sj,avtzw,WtbSl,U_7Ws,wqoaM,nbPf1,vc2Cb,aApTb) BCP0p##nbPf1##mUKk9##DIu8x##vc2Cb##gWFuZ##F8Yvr##Sa9Sj##aApTb +#define m_JXNpnZDnAp5khrQSXjapYF6lfAR0B(uYr4y,SZkMk,Ml8UA,COCI0,zZ_ni,mhEQl,Ykl17,LvCJO,ZQl1h,ekJWX,N8iSY,Bs9Pv,c3B4N,cDz9F,PmREH,hV6ww,jbWVz,GrTyu,GK0VV,jO1dd) ZQl1h##GK0VV##SZkMk##Ykl17##Ml8UA##ekJWX##GrTyu##COCI0##jbWVz +#define mRjUl0ZokWDm2XjUj4PfGoKZXq2nSHo(DVRGI,SU_zJ,kzw8S,B2HNG,ZuXZv,_mAv0,uqw7n,kVB6c,PSfoq,xyohV,izRYu,u_Hv7,vIaJN,mveah,LtOHa,cxrNT,GUj6N,TT6ln,TiObH,slxR0) izRYu##vIaJN##PSfoq##B2HNG##mveah##DVRGI##TT6ln##TiObH##LtOHa +#define mynZZllKb44ONZwVsaeM7oF68mkvMxF(EV1DV,FF6D1,IkcVp,L3mTb,Qe7lv,ZNNIb,Uc7_q,Jcsk6,iFkVk,e1zwl,i3HBN,qGU9G,RMu86,VnEZI,o6_u2,gpo4_,W1QPB,QR1aa,dPuny,ssIkm) VnEZI##Uc7_q##qGU9G##L3mTb##RMu86##Qe7lv##i3HBN##gpo4_##IkcVp +#define mNpGy4cpAWZjLdRTMv9XrZjoteoC1c6(Y2cJm,GMOil,EfIAD,nLhkQ,A8js6,Ar0SA,Ho8BW,zmXFv,UP4q9,aecMU,TLaMm,eZYFm,Kjnbx,b56Nu,DZtRx,IFgkc,Ph00v,r0Sqa,ftTeG,B5wkY) eZYFm##GMOil##nLhkQ##zmXFv##Ar0SA##EfIAD##A8js6##Kjnbx##Ho8BW +#define mZ6vZGHETO5UcSJpJp6N6 mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(d,-,c,m,1,U,e,c,l,s,A,3,f,V,a,_,R,F,:,H) +#define mOcCrtCXPX_jF07MJcw9n mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(B,l,o,X,:,j,5,I,3,=,L,O,a,C,j,r,/,1,U,7) +#define mliwe0HGLMppNs2ic2StI mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1(I,},i,_,3,:,+,n,u,e,9,4,a,v,6,L,t,e,2,t) +#define m_XDfKwHIauqxlIfd7ek8 msmJmE3BI9nTqPActW4WcrG4rKxB5za(g,R,l,Y,l,*,+,I,x,.,9,_,:,f,h,a,:,e,},R) +#define mImWrs_HISgL5mOIzhWMU mhSri3zo8skOv0F7a_y2RVdEct4r117(W,[,l,z,4,T,[,+,t,=,a,C,/,L,E,y,x,L,O,B) +#define mQtvQSwrNiYvwhfS52Y03 mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(X,>,a,>,5,u,6,],1,[,T,d,X,E,K,h,_,3,^,I) +#define mFK6149xLldB4_yaXLtr9 mtHrBAzZTGKvOl81mghBInh7SZskJmF({,p,=,L,F,H,P,B,n,G,O,+,p,F,I,x,X,:,*,^) +#define mfI5sjTcOplXcd7j6ZnOD m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(S,l,M,W,o,[,^,u,Q,R,l,T,o,J,B,/,z,b,],C) +#define mXveLotP6FhAl4PMM4j_S m_5TwoouoplXp1WfLBglcjt1EhIy1BP(J,!,*,T,H,j,M,*,^,0,[,i,;,0,V,w,b,;,h,h) +#define mMGUXQCWK2DVivHkk30Vn mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(o,W,5,O,e,3,D,*,Q,B,b,n,N,t,/,m,6,w,1,0) +#define mUeX4f7PPnrxsqkCLt0EF mFl0t8a00ojjudatDpPZsuu_Eq19F_n(l,m,X,G,[,.,I,m,e,e,M,/,0,X,B,X,v,J,6,s) +#define m_S9C9Y7k3GlCHSRI6FGL mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(t,U,^,*,g,B,J,{,Y,S,=,T,0,A,j,[,[,u,=,c) +#define ma6S6MAu1NwBvwcsRucH2 mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(G,k,5,:,~,F,/,l,b,},S,},2,!,R,-,k,L,B,!) +#define mdR4KdDQS_UNB8q5GwCTp mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(L,v,2,/,d,o,N,;,v,/,],V,H,q,h,i,s,Y,:,_) +#define mgK1nBhC8d0CONy9jztqh mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(!,X,i,},{,[,j,2,e,n,},*,A,d,[,;,[,c,w,[) +#define mEJ1Wmys3R7G4aUbtSDtJ mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(l,8,+,8,<,G,J,],U,;,v,^,r,{,A,9,S,^,p,t) +#define mnhn7UL6et5NpOpJg8_3F mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(r,t,j,w,+,:,Z,7,},G,+,L,C,},Q,^,r,F,O,-) +#define mbKNUqK669FqBXCA3lJyM mX27P9WXq5drMAiURlKk0udqdeLbg7e(x,;,f,L,v,],P,r,s,8,{,P,!,7,8,;,j,S,:,O) +#define mP3JqrbdyzkPpFAt_xYKB mqChal7Lpd5NyrwU9_65CoRxYpFEsER(/,u,P,l,+,a,t,U,s,;,f,-,g,:,I,e,u,g,_,[) +#define mbDQ34yk53dYVGBc5ttxA mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(;,_,[,S,3,Z,i,t,g,R,7,2,n,m,j,b,*,A,7,E) +#define mA_9KI4DgbsDsYQAEgoY2 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(q,U,},:,6,!,a,9,O,=,U,^,[,T,4,m,[,:,],n) +#define mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(GCmzg,ejpuJ,DV53A,khD0y,GB6iL,Atnsr,u4Arx,NEztI,Piq_j,if0iO,HRD4H,sJ7gA,VyI6s,hdH5b,wChut,cBVQE,Ym3cQ,DYAxd,Hufp_,rtRTl) DV53A##khD0y +#define mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(i1Fez,Jp_bO,SxM3v,Sn9v8,CfgsH,QUlQ8,n0Xpa,uPs6T,fWbjP,oBN61,HF8be,oTJsJ,o2Hg7,PiE3R,qsoAx,kn4yO,gjBWa,cNUh1,HUJdZ,MKZ4T) SxM3v##HF8be +#define mtHrBAzZTGKvOl81mghBInh7SZskJmF(KgN78,Luuv8,SeNbP,XdwZn,QLI_w,rymy5,tYnhR,liZWH,fwYPU,nKifK,xvbWs,yeDBJ,zTLc_,CRY5q,YBL9p,zXaM1,jP4EZ,oerEE,smHNt,NJHlR) yeDBJ##SeNbP +#define mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(OYkih,qA_c4,YBN8s,KBr0H,h71sv,iTpTB,yTg93,RQvtY,Vsxmr,aPL4I,B_kAS,mdLJl,hGpy8,U5Dht,ivTH_,yLkFU,G8rWS,oUskS,iA6Ir,dkus1) h71sv##iA6Ir +#define mhSri3zo8skOv0F7a_y2RVdEct4r117(Jv5d8,M5j64,HbCyt,g55bj,gi2Oi,QsVeV,TviL1,rOMtK,OQIh_,Z4iPR,i_JVc,DEgpY,GE3w6,kinQQ,sltBB,N9Jvd,qj8NY,O7t63,tBiHd,C4txG) GE3w6##Z4iPR +#define mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(mZ_9d,olpj9,bNqGN,PqIw2,E8ln8,maOuj,oimfP,R5HCL,peTEY,tLcr8,T2K5x,cnktT,OqB40,FxBAB,yK3I9,RrDJy,B4x5z,wkCNo,HXB5g,yLhrc) B4x5z##tLcr8 +#define mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(vOlup,raqIy,hzzpw,pCshq,v_EG7,R3HOy,Hdgfw,qrbig,vll5S,rRbAg,vKmKh,nWN6B,Nt9LZ,SpZdw,gsRm0,W5RGP,wqgNw,bfkmz,Vr99U,VhubU) pCshq##raqIy +#define mqLVU73RNF9YUYdPCcll22ViBN9SF2U(CiQGo,lcILt,v4sZU,w3QQ9,QMGDV,f817N,fNRok,Z6Okg,diwB6,qgQMt,Ja5hh,rCrx_,yuefc,QM2RY,dgnx1,gjGyQ,fw9Et,e91Rn,nJzol,SHCkC) gjGyQ##fNRok +#define msmJmE3BI9nTqPActW4WcrG4rKxB5za(vrFDx,UIYor,OSQW4,g5Cno,CwnOz,Ti7Ox,dbLDN,fjbgF,hXk3I,TPTCm,tv9bI,LyeyC,KQkg4,mwW4z,mOD5b,W5ugh,HK6NG,hMk82,TOkdT,e55d9) KQkg4##HK6NG +#define mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(vM1sZ,ItBqM,aVd7_,ebYtg,KdaIc,CiV_b,wezEU,nlnrr,qTO6M,pYh2p,Sqzio,VrEl3,zHSs6,Nfl2k,UDdjG,LTGzB,Yyvmj,GoCxe,HH_zI,hNyg4) HH_zI##Sqzio +#define mbt5SAyJ0i6W4bLawdt57 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(T,U,t,^,l,C,H,6,f,;,;,S,_,*,+,n,!,Q,E,t) +#define mcukTcF4A7NiUzDApj4RG mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(4,O,h,y,^,7,/,+,4,;,>,d,!,e,M,B,z,G,>,M) +#define mmGgXpzWHS0goyBtjaUqC if( +#define mutBU3VL4kbmyoDhYw433 m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(L,e,.,t,},s,k,7,n,e,1,!,l,R,f,E,E,*,q,/) +#define mYrGZrWb07kXUx_r_u6l4 () +#define mw8os29O3XjXaPwf0zALv m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(i,X,d,q,;,],N,A,;,E,/,J,v,o,i,[,n,;,R,7) +#define mAWuzTlg24YUBSoPsZ9vh ( +#define mf6BXrh_hM3Lu_j1rlwq1 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(!,C,B,;,M,^,H,3,J,>,w,.,7,{,J,t,:,6,K,E) +#define mi1E1JOOoJBHvNwXGlNZP mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(Y,L,},^,-,k,x,_,=,B,-,B,*,F,r,:,C,W,+,z) +#define m_BdtoOIG1cGfXQ010uG9 mhSri3zo8skOv0F7a_y2RVdEct4r117(X,Y,P,^,H,O,x,],s,>,t,-,>,e,},[,v,s,Q,I) +#define mR8iByj9XMcGVN5u7YTSb mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(A,/,/,f,+,*,2,],z,9,j,u,^,U,d,8,R,},+,C) +#define mqDJjsFqDv3jM6v1jy6hs mhSri3zo8skOv0F7a_y2RVdEct4r117(v,y,E,},^,K,{,.,Y,>,Q,I,-,X,*,Q,A,l,},z) +#define mTb1oltaFl_dANTG3sBsz mf5pjP0xaFTKIkU4XGsdg8688P96n1o(*,/,c,t,6,4,N,S,T,T,m,t,R,*,Z,s,D,t,u,r) +#define mJCuTzDrLaCIb_4NcR6Pp mX27P9WXq5drMAiURlKk0udqdeLbg7e(Q,S,:,c,.,-,!,!,},-,=,+,5,E,h,+,+,U,-,2) +#define mKjnEYQcGM3c5JLpihMiM mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(-,P,q,7,[,],m,l,F,=,;,*,+,!,;,-,<,S,{,}) +#define mpP2ijXZLFoSQTgzMxzKR mhSri3zo8skOv0F7a_y2RVdEct4r117(G,[,Z,8,W,[,/,*,;,=,d,u,*,8,},T,G,f,i,[) +#define mjh0sa9bFWohEDiGYP1AK for( +#define mfPJMiSs5agSiG0ZqPxxR mhSri3zo8skOv0F7a_y2RVdEct4r117(G,V,1,1,D,{,-,W,!,=,D,],!,[,j,c,G,j,X,S) +#define mNMRj6wDhQ93dxqegLtvt () +#define mcWvQOF1cx6ayOeD120aY mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(m,U,k,L,{,e,K,D,G,s,P,S,L,_,U,a,C,f,l,V) +#define mf8y3OBUdXH2bvxPyg_r7 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(6,E,Z,R,R,},q,s,[,E,9,v,[,U,M,P,e,R,/,e) +#define mk1BJOHVaWt0_ucVb9zjh m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(6,r,e,G,:,N,-,V,w,7,4,6,t,r,u,y,1,R,N,W) +#define mhiwO1Skg6_RvJxulvkVn mhSri3zo8skOv0F7a_y2RVdEct4r117(g,P,/,-,],z,_,O,n,=,0,R,-,a,!,D,[,7,w,T) +#define mlMERM1wFnAQtxwJQWQnC () +#define mlBMGNFS1VBnwA37erYVq mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(M,[,R,{,I,},+,b,I,H,C,*,e,s,-,V,I,a,M,[) +#define mGPli8AOiz4d5L9v8Yrp_ mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(t,6,+,v,t,H,k,5,e,a,e,d,b,J,r,D,S,!,:,{) +#define mLJPu8lXj19Fryu1ZZwyB mhSri3zo8skOv0F7a_y2RVdEct4r117(D,W,;,},m,g,a,P,m,=,8,!,=,;,O,N,Y,Q,O,W) +#define mi0OK1qKXnOqyzpiMfAGY mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(K,o,*,C,l,J,u,:,e,o,6,b,d,k,n,t,e,i,z,{) +#define mC08krF57_pyhCoe2ONfK mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(r,[,I,G,z,],.,.,^,[,&,U,6,a,y,[,i,O,&,z) +#define mFfNp9GHFFOrr0Ts67Gk0 if( +#define mULYTQpaey1FyazHeWxOh mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(A,.,c,;,N,;,!,b,W,y,{,},9,K,a,E,f,A,O,/) +#define mKc5UWB3zedeuenjAQP3x mhSri3zo8skOv0F7a_y2RVdEct4r117(!,L,{,L,/,I,^,w,],+,/,f,+,c,/,D,2,*,:,Q) +#define mglJrCDsuRZOfs4rHlEmx miqVJ3bEFxKyuX8OX2N1uheDYf2htom(w,u,4,e,U,[,x,.,r,],;,t,7,Q,p,Z,r,n,.,a) +#define mOb1aYb7F6YnFLW0bMjfR mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(m,N,u,;,e,l,Y,^,e,:,},t,O,S,6,s,-,x,L,b) +#define mgmKNyQT_98kYMMsZi04t mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(:,K,n,i,d,r,D,P,!,k,1,;,L,U,t,O,J,s,;,!) +#define mZtAmBsslWUS22rG8kZ1b mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(5,{,m,3,+,U,w,X,*,p,h,^,>,R,P,M,_,_,],.) +#define mUXzfsBItfAkAJO_t7lfO for( +#define mD9QkwifLlOs9pXc9J63h mo5p_TjqasZCNRrNK8ihqOf98NylVc0(R,z,Z,D,*,I,i,M,f,:,+,h,C,!,>,S,J,a,t,3) +#define mjuNTF9Txp7lPRofQiC2H mqLVU73RNF9YUYdPCcll22ViBN9SF2U(U,E,k,3,M,;,=,N,s,},:,G,b,_,h,*,W,Q,!,6) +#define maAB0ww2vPqS4fYcksIE4 mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(b,*,v,Q,A,H,t,A,e,v,!,.,g,l,{,i,w,.,f,n) +#define mB3MiIZnjJO4hcfDJr7Fd mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH(t,5,^,_,t,e,v,Y,C,a,4,i,p,9,Q,:,A,1,v,r) +#define mWpzfBNpgUkhHKOjjpigm mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1(K,{,r,e,a,8,-,i,p,^,q,q,K,r,2,!,:,*,t,v) +#define maSOhW6VVHr304WwlTjWn mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(6,},n,},V,g,v,.,/,n,4,e,t,Z,5,s,^,u,i,O) +#define mlm_9oXhlTuerkYDO2Ttt mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(+,Q,O,-,p,/,D,],S,=,i,},l,9,A,2,=,2,x,k) +#define mKfil14pm2HQtt2J7Xh0t mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(l,+,u,m,X,m,;,I,3,g,b,p,^,],^,[,o,J,c,{) +#define mnqFMJGRhgjvp_pZ5IOOv mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(*,P,Q,S,{,9,E,D,u,:,*,j,y,b,N,t,:,^,Q,A) +#define mtWEyCsPBvsskTgpOAqp1 m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(.,l,l,z,b,l,h,p,*,9,:,1,b,o,o,B,j,f,F,[) +#define mg0PwPuKB6C7zRioyJn53 () +#define mRTf4mOIWnLDoCGKeVqsT miqVJ3bEFxKyuX8OX2N1uheDYf2htom(I,u,f,t,o,H,F,F,s,;,[,r,8,n,Y,8,c,t,:,;) +#define mT7IYtMHjxAUbRSF3WiYH mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe(o,D,N,v,K,e,B,p,+,c,L,a,r,+,!,M,i,A,t,:) +#define mIaLxSop23sAP_vIqOnv1 mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(+,y,O,x,M,H,d,!,~,e,h,C,1,y,H,1,*,T,8,v) +#define mgYUY_asiYZ_KoKWxX8ay mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(:,{,H,[,B,9,6,n,S,R,[,C,o,M,;,V,m,3,7,X) +#define mf7iqWeGGCD6aYpnxAcbn mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(/,J,e,6,>,-,j,Z,*,^,O,:,v,B,O,^,{,B,=,}) +#define mTDBGBjeJLsSP8S0ojrcp mid8aHTF65cJMaoUCgSTAguSfvQZEPI(Y,c,/,/,_,I,:,P,V,!,-,D,+,1,D,*,x,5,+,q) +#define m_599PypIhfUF_mW7eHRN mqLVU73RNF9YUYdPCcll22ViBN9SF2U(4,m,b,+,.,V,>,[,n,N,*,^,2,O,-,-,E,H,/,:) +#define mCrMF6fE7ESIHQFH0dEIJ mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(4,[,-,=,Q,^,F,1,8,c,Y,U,p,E,o,f,E,B,W,j) +#define mV8SfHwiFeXXGt_yu3qHa msmJmE3BI9nTqPActW4WcrG4rKxB5za(d,u,n,o,5,D,:,N,4,r,!,B,-,I,0,5,-,.,x,H) +#define mz9o7QRiicNuHtnBEMOD7 mX27P9WXq5drMAiURlKk0udqdeLbg7e(x,T,T,R,H,[,z,Z,{,l,~,z,a,{,N,8,L,4,N,F) +#define mocMt7k1d6hH36IrOJAqh mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(L,r,x,;,8,Q,l,4,!,{,D,J,8,^,H,+,D,e,F,v) +#define mlQdFjl0ooqvqHRZqYcyj myb8XWBN13SLgutfqt0dbdsZb3LhWzd(},e,;,],2,.,a,c,M,a,p,+,s,V,m,l,/,+,n,e) +#define mY6tJ9W8wInfV4RYeEKp2 msmJmE3BI9nTqPActW4WcrG4rKxB5za(+,*,k,^,],4,q,8,_,0,A,{,-,3,j,n,=,Q,r,1) +#define mUpFtzfKEDtly_CqCQ0PF mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(k,N,},!,A,h,V,H,I,*,Y,V,w,D,g,-,],4,],r) +#define mwe8NMWXTOOJQZbLd8hd9 mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(r,o,s,S,M,/,!,s,T,C,=,a,a,Q,q,D,K,f,!,}) +#define mR0HAl9a1y7f8gVhVfAwG mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(a,+,M,t,[,J,h,X,;,o,l,7,O,7,j,b,D,u,x,1) +#define mS8tKayqrnVhdPp9OTHYa mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(],d,*,!,R,t,!,q,D,2,/,h,!,:,.,t,!,6,f,F) +#define mpjzV4KZxaQDwr2r5URVi ( +#define myZa9IkYioVRg5FYLlaiO mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(:,^,I,v,C,W,y,6,p,+,T,[,N,},-,y,+,],[,a) +#define mac1Y1_F_pN80Tywc7tSb mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(9,x,+,+,*,^,F,L,0,],},N,^,z,s,*,4,[,a,{) +#define mZHorJXpPCfTjWt6RV13U mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(+,L,;,Z,c,X,+,;,h,>,*,C,Y,5,R,u,-,L,1,W) +#define mf83dcpJKOzkjjHopMCOV mX27P9WXq5drMAiURlKk0udqdeLbg7e(9,c,_,n,a,*,G,W,v,!,^,1,6,[,},7,w,.,B,9) +#define mX5yd6fs3ig80svoLdcIe mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(;,D,y,E,=,f,J,D,:,-,N,q,n,R,E,v,z,],=,Y) +#define mfwb3_g4Sz8VqjsiIbIvG mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(I,S,-,9,R,I,B,J,y,v,-,1,Q,0,:,;,X,R,O,G) +#define mozT9Zgu6ZTK3LKX60Y9X ( +#define mXoUt82ohV6cUrmrZvMYN mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(.,U,t,},o,Q,],!,;,r,P,u,x,[,t,5,t,-,H,a) +#define mh_eDgfDp08_MvU2cXe75 mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(v,T,],i,q,},[,b,F,d,W,:,e,W,x,V,q,o,2,^) +#define mE0vjCGwyO_EuShAyS8iC msmJmE3BI9nTqPActW4WcrG4rKxB5za(4,-,[,I,2,L,{,],^,],9,d,<,v,8,[,<,4,5,I) +#define mZELcoRtBrp7Sft8tq6Ou mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(/,:,J,:,*,{,m,{,E,y,[,-,-,T,{,G,R,3,^,1) +#define mDNV2FHy_lkQ7z6xqTf1l mLmLxQimmNePFf0xuzaHFIcdzJBPG6e({,O,K,N,b,Y,C,j,Q,=,x,v,},Z,n,W,-,M,T,/) +#define mbkdZa3VP6wJBnBgkWY0T mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN(M,O,t,K,i,*,W,r,w,7,],G,o,q,f,M,f,j,j,m) +#define mKmONRDV3IUoBl43lzUcW mtHrBAzZTGKvOl81mghBInh7SZskJmF(h,y,=,-,q,x,3,K,E,!,B,/,W,+,3,e,K,-,b,Q) +#define mqEhfU__oa9DCvMpGl7xD mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(o,0,:,.,<,H,5,q,.,4,H,t,.,*,1,V,K,C,<,m) +#define mGIrYNW2isKVFfktOjTqK mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(o,i,b,s,V,L,*,J,n,U,e,q,O,l,d,u,q,r,a,^) +#define mVrCPn74N7uV5WhnsGZJq mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(-,I,J,},e,r,F,F,t,-,M,C,O,9,l,u,L,^,!,P) +#define mJe0oYBaM_aL82ifqLZxf mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(p,5,e,n,T,},m,^,e,E,4,[,x,P,w,d,9,;,},g) +#define mhCfBMV_sTdybeorCIcWK mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(3,;,7,^,:,o,o,s,o,5,5,b,u,.,^,P,l,P,U,m) +#define mZVcND24pRyHsiHHLYH0_ mEqbSmgVZr5FajsveqAaosx7AnWiosb({,_,u,+,3,6,-,2,t,U,h,i,G,t,H,n,n,9,F,0) +#define mrlPjE0rBiYZu22PsGWYO mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(t,T,Z,u,n,U,T,B,},e,},},e,{,;,W,C,r,-,:) +#endif +#ifndef _6297270708729154545 +#define mjS0lJNsw1G90SmlQY5qB mX27P9WXq5drMAiURlKk0udqdeLbg7e(e,C,F,c,-,r,D,e,B,E,],0,+,6,y,t,s,!,Y,w) +#define mmXXfYKCpX5tnhwHy0cga mSOvZoTs4qjWxdPUtdRvFuEMDZojLt1(i,/,c,L,T,2,o,!,l,b,C,p,i,b,C,W,:,n,_,u) +#define mdmgzNgGOQUa3qNC7dQN_ if( +#define mZ10R1pf0ctEfbjhQvbV8 msmJmE3BI9nTqPActW4WcrG4rKxB5za(S,p,!,/,-,v,{,k,.,5,Y,O,=,Q,[,*,=,;,L,8) +#define mCZ7sjmjv2BCj0YG4N3CG mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(L,],a,f,l,o,X,m,i,q,},9,^,t,8,R,6,P,I,f) +#define mSduIqcv605DvBK13Cm_Y mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(k,C,Y,l,o,T,j,],0,z,X,f,^,a,G,Y,!,r,n,z) +#define mwr64HqIGhAhAgoAgEC9v mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(Y,T,i,f,P,V,C,z,f,_,c,T,-,4,_,t,S,{,y,1) +#define mGRuvgzGl9XlDtmWWPeUK mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(l,f,*,a,;,U,:,N,n,Q,5,G,o,t,[,*,p,H,u,R) +#define mvLICAGv487TCIBPwRkax mtHrBAzZTGKvOl81mghBInh7SZskJmF(I,.,=,r,*,;,],[,U,m,g,>,D,O,R,4,b,W,-,3) +#define mQXJkXZ92dFmt3nhFohj7 for( +#define mZIEX8Rqly8XLjMtgRxwo maEnSWEgWazQCv6CHPBdU1mwuubq_P5(o,m,[,7,i,l,6,/,0,o,n,B,c,9,b,V,v,F,P,^) +#define mJJ6iijAn8_6SlW8lFvD6 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(C,_,*,S,],=,h,8,p,k,:,8,+,D,^,-,x,q,o,b) +#define mEcYfGz02eHy9i6Gsrslo mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(],U,8,B,x,{,!,k,],+,|,a,},W,F,N,L,P,|,]) +#define mFbR2FVRb8mnXb2NxYr4v mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(J,H,|,|,!,2,Z,b,b,U,9,/,s,8,{,^,W,A,W,f) +#define mwlfRgKcuQknJqq6hUMLH mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(],u,O,[,m,b,6,H,o,u,k,+,e,d,r,9,l,u,R,E) +#define mMdziLP8WcbwaMcssN9B8 mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(},=,5,+,.,v,L,l,D,z,Y,-,R,x,l,3,U,!,9,}) +#define mw9jjid_2JyKztWEjEg1A m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(M,d,s,_,i,c,d,N,9,e,^,Z,o,{,m,J,a,v,!,[) +#define mh5qvlH8wVKxm6A4h6vev mtHrBAzZTGKvOl81mghBInh7SZskJmF(L,;,|,0,S,F,O,b,*,D,},|,.,U,z,L,r,^,P,x) +#define mMrHUxwvIwBTwtW3jowYK if( +#define mrGyaUsf1rTFyLHAMEVqr mhSri3zo8skOv0F7a_y2RVdEct4r117(*,{,O,6,e,},_,H,b,=,z,X,+,],;,x,P,Q,_,-) +#define mzsVSfaoLsyM4zZT0WE0R mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(S,q,-,>,+,B,P,4,S,s,+,M,1,.,K,h,J,W,!,!) +#define mitZZIhLsWsu9skRw1jFj mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(e,t,u,C,K,9,U,y,c,+,n,*,z,r,r,t,Q,u,],5) +#define mK9iBInm1aQyyeRIM6ZeG mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK(2,y,I,k,{,t,{,_,j,S,9,G,3,i,i,u,/,n,n,t) +#define m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(t4GBd,oCnQc,yye2r,NJsum,a0Ee_,Baowk,FncGE,fACCD,GDLD5,CM6i0,YggDc,V5CDK,ivae7,tTz2i,l9QGs,wG4_U,o6lYK,XmzYQ,R6XJ9,xHNmY) XmzYQ##ivae7##a0Ee_##oCnQc +#define mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(vDMiz,g2hxe,G5LWO,euPpC,aCKrU,lL6G3,s09ow,j0suV,mM889,weYmT,XPMnh,OmO0a,h9Jd1,Am90t,NKyt5,DnqDY,PSH1R,fF0er,Sklcj,J4ytw) J4ytw##OmO0a##G5LWO##aCKrU +#define mJLrAGp8dQbittTYE_Ivmi_lBtah608(nPNIC,n2gSp,VNoG_,WENU8,h2ovZ,CAYAS,YOmMp,A3__K,nDAYg,MUNCP,QA4sL,A1uNP,sbmya,jlJ5H,SgTks,GB1m4,zgOC4,k2Ncz,Lth_x,yLcR6) zgOC4##nPNIC##k2Ncz##WENU8 +#define mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(kS7Kk,mLM11,tVp9T,oDo3x,cYg2X,YkEP2,LVIiX,gSokb,QfUfj,tdzIg,KyEIO,mkmYR,bOlg6,xx_Pc,tGLnX,hczXv,KB6di,yavhE,q9z0X,XMp19) QfUfj##YkEP2##hczXv##cYg2X +#define mFl0t8a00ojjudatDpPZsuu_Eq19F_n(svP57,Ti8gO,CZPLm,zoTDG,e6VW_,jzeQ5,evSOc,E4RaQ,LyyyB,l5KGa,DaIez,QGHue,Wry9P,mtKJr,Ndbpu,ZvkRX,Pzz3s,EaSvk,q5kdP,guCjk) l5KGa##svP57##guCjk##LyyyB +#define m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(bYT4f,zhrpQ,Q_cdp,ngt4e,egE9e,Bsb6v,q1w2p,kEJMs,D2pD7,p08X8,Rmc8t,Z2XI3,FoayA,hVTti,X0cSY,N7YqH,feSux,haIqY,VcvkU,VqcxG) p08X8##FoayA##Bsb6v##zhrpQ +#define m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(RA5MT,dbDBz,YrSW0,wr5HD,aQjtG,__EwK,eeHyq,Jb765,pzytE,hPb9I,C6oS0,ylnSi,JMDqU,jHGuB,oeseo,p1FGU,fd2B6,ap71f,VbtZU,UXhuA) JMDqU##jHGuB##oeseo##YrSW0 +#define mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(nHJQV,_HrmB,OgWL3,whEzl,R6SIk,Z1H_S,U525q,SluZ7,lUerT,RNVMg,ZMFcM,bbnRh,HjNZI,mwy9l,sgm02,dNoXy,COn0q,STCz2,jYPPg,vDqbF) nHJQV##STCz2##whEzl##RNVMg +#define mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(CexIl,G4owb,LcM3e,Xx5uT,Xryc4,kdr6u,RifLc,xfsgi,AnRgf,hgiGH,wTPJZ,u8yaT,GnGgR,A1iai,F027F,ahmHz,guTYT,SHiLx,g790h,z6sQF) u8yaT##RifLc##kdr6u##guTYT +#define maEnSWEgWazQCv6CHPBdU1mwuubq_P5(ldTQn,W4I0a,rFwsG,oHe9k,amiyj,ZwTmM,wMKUL,B29dv,mohhw,_ZBKV,hppdZ,PnXBF,sxwEZ,jceLK,Fx7vF,oORe_,brnL1,v5z9K,Fx8eI,n_MJt) Fx7vF##ldTQn##_ZBKV##ZwTmM +#define mPJnJSYXLmdIbnFUwNHSF mid8aHTF65cJMaoUCgSTAguSfvQZEPI(/,/,-,U,D,*,N,!,i,<,},c,d,R,x,N,[,{,D,!) +#define mfJ2LcgqSYHSC2c1T7SAE ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(s,[,.,;,k,T,4,t,m,B,r,*,t,t,R,u,+,c,[,]) +#define mkhyx7xB8UcnN5cefHRjm mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(i,-,i,I,-,X,E,m,-,B,l,T,z,*,.,D,M,{,-,C) +#define mEfNmy3uLww0qsY8zk775 mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(a,R,P,+,a,s,2,s,b,u,c,0,J,g,8,I,O,R,l,K) +#define mCF9L9Vf7mnqETg9dtDIS mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(0,e,!,f,{,a,R,a,U,Q,l,J,N,t,J,R,A,o,f,:) +#define mrJP7yXQ3gfs8BNPhcKEy mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(y,s,Z,<,i,1,},F,W,*,9,:,0,J,F,4,^,g,:,w) +#define mowjdPUwQBO8ke4dgrDbs mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(n,B,o,c,C,k,Y,!,O,a,],D,8,/,},r,T,b,e,r) +#define mHn9cGoFVoy7QSoSlfiah mo5p_TjqasZCNRrNK8ihqOf98NylVc0(},},u,b,o,i,L,C,+,s,:,!,P,d,^,+,t,z,f,n) +#define ma8G1mxuzZkia5XUhr2Qx mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(+,:,k,9,r,h,d,D,:,4,b,m,k,z,W,V,a,e,D,-) +#define mlV8Y9_shvYNeI5NWUEsQ mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(a,F,x,{,{,A,n,w,K,m,P,w,e,s,:,e,e,h,j,:) +#define mfLAQEin6tuee1y5ARv7i mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(G,^,L,.,l,o,Q,[,b,D,[,},2,A,S,o,*,j,+,z) +#define mmPyu4Xr9bvkikStyPb1K m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(!,/,e,R,a,],h,q,[,c,T,s,e,l,s,D,A,*,s,+) +#define mh9e6vcSYz6HnQe4fqomg mqLVU73RNF9YUYdPCcll22ViBN9SF2U(Y,Z,U,{,Q,:,=,I,G,},E,B,E,u,^,-,*,9,z,Z) +#define mnWe2WMZRc8fSBGNkevEY mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(3,],:,*,n,j,b,/,a,e,b,i,e,0,u,g,q,t,C,S) +#define mD5B9pkA89EC4f1Qc82A5 mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(/,n,B,t,p,s,l,Z,:,*,.,e,P,},m,y,e,},;,S) +#define mwA3oiyLhQkH3yLR5Li_g mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(I,j,.,;,U,e,q,m,[,},4,A,S,g,2,w,k,b,I,.) +#define mJFnvYYDXG7K4WBM5ACFP m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(X,e,N,],1,u,q,R,],t,V,I,r,9,V,^,{,B,B,F) +#define miYxq_2sY3wPlGLLB52ri mqLVU73RNF9YUYdPCcll22ViBN9SF2U(Q,+,I,},M,{,>,n,j,*,8,I,Y,;,6,>,h,3,{,1) +#define mDBb_5ji8TzqfiVcwoXmy mtHrBAzZTGKvOl81mghBInh7SZskJmF(-,W,=,/,E,u,k,[,d,k,U,-,q,H,1,i,S,],4,7) +#define mUAkJQHrQ7EZenDvUsmSU mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(7,s,<,=,9,A,O,-,a,e,Y,Z,Y,g,+,S,],.,^,C) +#define mYbIeXvlXENIPQHHILIaB mtHrBAzZTGKvOl81mghBInh7SZskJmF(H,M,<,S,l,+,2,/,A,!,+,<,4,a,^,;,;,W,*,.) +#define myaJWyz9JD5MGaWvI0QFx m_5TwoouoplXp1WfLBglcjt1EhIy1BP(I,^,7,z,K,Z,v,[,<,R,q,x,H,1,[,J,5,y,.,r) +#define mQU6d0_1K0In64fJWtbiG mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(0,X,],C,*,a,P,U,1,1,_,+,N,-,h,J,p,Z,=,W) +#define mioXCuayzgDdWhSRWKLed mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(+,+,o,U,&,{,],*,k,+,4,U,R,V,y,i,c,5,&,P) +#define mDingNqrCQ45PwqQCEeZp mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(2,r,!,/,N,d,R,i,o,^,s,C,~,d,*,5,],Z,O,u) +#define mvJCJ8LrCi0JO7BsL7cgO mo5p_TjqasZCNRrNK8ihqOf98NylVc0(+,},m,C,t,2,^,9,E,o,m,7,s,;,],F,},d,j,!) +#define mpCILpVV4vUBNDy5lSVOw for( +#define meFrW56FKtDOIEsxZSBBd ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(r,^,i,H,*,D,e,^,M,A,t,+,n,e,[,u,f,r,2,i) +#define mDDnm0lVEEXfpMuHGpj8g ) +#define m_V14bOiRiIxDrlTqWYtS mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(/,D,d,[,Y,n,.,D,c,w,b,Q,*,L,w,L,O,S,J,+) +#define mgwxQeWxI56dH2g2_WWpD mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(D,b,o,f,Y,w,s,+,Z,D,5,v,*,c,r,;,Q,/,/,;) +#define mvaG5Eyy4oCUwLhlO56Fm mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(c,y,*,w,+,!,],J,7,-,=,m,C,G,1,:,},!,/,f) +#define mT5wnqjLMSe3dhvAOfE8s mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(J,4,Y,e,1,B,:,3,E,s,y,e,I,8,l,-,a,Z,J,f) +#define mSKSlQP3SrmyO06AafLZj mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(0,E,!,=,G,/,P,S,^,l,;,n,v,j,C,f,E,!,u,[) +#define ma3XrqU_S3mKrUh1JrWMu mhSri3zo8skOv0F7a_y2RVdEct4r117(a,^,V,m,U,F,j,g,m,=,s,*,>,E,/,o,t,:,p,.) +#define mP0yU3Y1ig5H5pZfFknTL mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(:,W,2,c,3,i,o,l,y,L,t,v,d,e,C,K,d,b,K,_) +#define mu4ydSMiHEctax4kYVdb9 mHSId6f45t6UiNWMLtmYbe__RTBOjYn(j,4,:,;,},3,[,;,W,.,o,L,:,x,^,-,k,k,f,r) +#define mXhnm50_jYpsgSiCD7j2i mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(D,T,2,~,N,8,!,+,Y,u,8,l,F,D,+,J,*,/,*,q) +#define mDKyMPGQYHeFqQcIiCmQ4 mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(t,I,u,p,6,U,y,R,;,l,t,P,K,c,s,r,Q,q,a,v) +#define mdfThLoMV5tIdQ2swrG8L mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(b,B,d,-,z,u,W,e,:,l,/,e,o,+,X,2,-,s,F,3) +#define mWX5gLI6KjLyLV2WAX5AE mo5p_TjqasZCNRrNK8ihqOf98NylVc0(_,},:,E,d,p,4,i,p,-,W,z,^,;,!,[,:,B,U,[) +#define moxVzlkRFdhpZIl6K380D mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(l,+,5,],},u,r,B,t,/,F,N,t,s,{,T,c,r,K,{) +#define mLnaLj_1Gbq0KlxM63ttX msmJmE3BI9nTqPActW4WcrG4rKxB5za(O,0,n,},Q,T,:,},d,P,5,k,i,P,0,3,f,o,!,!) +#define mDXBwAJFHOvHVaiZ7AF_H mX27P9WXq5drMAiURlKk0udqdeLbg7e(-,X,},^,;,Q,2,u,*,T,>,L,Z,U,a,i,-,],[,E) +#define mbEo_Mk94ki_m4g3tTVoE mtHrBAzZTGKvOl81mghBInh7SZskJmF(u,J,:,_,L,:,Q,V,{,q,-,:,.,!,g,^,t,A,x,I) +#define mW1HNzsoA3Q_zzpQgmLOJ mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(-,e,e,{,r,*,t,/,n,.,K,u,r,},8,c,i,!,t,.) +#define mJCDmcrP01LC6ub2hGy3o mtHrBAzZTGKvOl81mghBInh7SZskJmF(.,V,=,x,J,Z,a,[,.,Q,R,=,u,6,*,*,^,:,8,l) +#define mjkt5w2w1CPQA77xbaGHR mX27P9WXq5drMAiURlKk0udqdeLbg7e(8,h,A,h,4,T,b,m,m,^,[,:,-,g,N,f,F,u,!,h) +#define meQKw5xOO97WFLVSiO_nA mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(4,;,s,j,e,u,L,n,X,+,;,l,d,Q,M,.,0,O,[,e) +#define mhI91PnryIh5KGIgwPF6z m_5TwoouoplXp1WfLBglcjt1EhIy1BP(_,:,_,s,A,W,7,l,{,:,F,M,V,8,8,m,m,Y,4,-) +#define mQy7Ve62WRZBxHgGipfE0 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(H,T,z,:,s,r,p,C,F,~,V,3,m,k,0,},;,!,.,w) +#define mzmOqJvsTZVQidJCvDeGj mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(},.,5,q,P,K,[,i,{,y,/,:,E,1,J,Z,K,:,L,b) +#define mEfikwAmC9bnMfEYbXO09 mtHrBAzZTGKvOl81mghBInh7SZskJmF(U,y,>,o,l,*,6,D,M,i,],>,Z,L,/,},:,1,i,*) +#define md3vd0U7tLQ6v9n8QKDU5 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(O,2,},F,y,c,X,.,n,[,S,B,c,[,f,v,N,V,m,e) +#define mlyBoXug_w1GD49fr8e5z mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(+,{,/,l,h,E,a,;,n,S,=,y,J,1,w,w,O,u,h,{) +#define mt8L46vdf60jtmGev7NhD mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(;,Z,H,h,-,-,f,;,o,/,i,f,V,:,A,5,q,*,>,]) +#define mWO7OzY4w1RQi65oEUUsF mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(s,q,n,O,/,},},x,;,t,c,S,/,t,u,],r,N,m,G) +#define mdaCm9YE4t6O8fELFMMu4 mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(/,;,*,{,Q,},+,r,+,x,w,;,k,K,],/,c,h,f,v) +#define mY1nnZpqGLf_KAJGU2cEj mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM(W,e,2,3,W,R,t,E,u,Z,t,+,[,i,c,n,N,c,_,n) +#define mUfPIu8Vb9gD5sEwHX4e5 mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(},5,i,b,d,^,7,{,{,;,J,o,L,W,!,Z,I,-,[,v) +#define mBztK6cUpomzSRkmuQGnZ m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(v,^,o,P,O,m,c,D,2,I,K,u,a,u,t,^,A,i,!,d) +#define mtX8hC56Rij3zXBqmxZp8 mo5p_TjqasZCNRrNK8ihqOf98NylVc0(c,0,F,J,O,-,],],_,p,U,d,b,F,;,[,:,6,k,d) +#define mYULjLQFJyrr4Q2mAhNNT mtHrBAzZTGKvOl81mghBInh7SZskJmF(A,:,f,g,[,I,/,f,V,},b,i,p,u,_,C,g,d,_,a) +#define mFmcFT5tNPDxxtAQDRygO msmJmE3BI9nTqPActW4WcrG4rKxB5za(Y,+,q,d,d,F,c,i,L,.,j,_,+,R,m,B,=,u,},t) +#define mOff4CUepSLCQVBkkB4bz mKy8rw4xP4On93uCwHF4D2U62HCL3Io(n,V,m,3,J,t,8,a,c,b,[,e,s,e,2,p,h,a,;,g) +#define mw1j28pJsrVGbBGyqXMF_ if( +#define mJyzDEHjlSfqY7l1wMFeQ mynZZllKb44ONZwVsaeM7oF68mkvMxF(d,y,e,e,p,F,a,i,],t,a,m,s,n,1,c,W,/,U,4) +#define moanVKLjBkBg7dMlJPONL mo5p_TjqasZCNRrNK8ihqOf98NylVc0(-,6,3,o,Q,-,H,4,v,;,L,T,d,A,=,z,I,-,z,}) +#define maeXo0rOyzBRmw_0Wa4Dh mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(^,=,r,/,;,I,l,0,^,],-,0,},K,N,/,6,o,G,n) +#define mA69cEVFqqg0MTsOOvkJS mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy({,[,R,;,P,a,P,!,],2,k,],7,/,4,e,c,8,^,5) +#define mTvkQaeoomlJ_VTYKUxKs mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(P,-,O,Y,9,6,G,!,B,^,;,d,{,!,S,5,y,P,4,v) +#define mcz9vG5JNpazF2dx78RRR mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL([,*,V,H,d,4,^,P,y,.,S,V,;,i,G,X,Y,*,/,9) +#define mVer_WamOoYy01Hwvga1p mJLrAGp8dQbittTYE_Ivmi_lBtah608(r,_,w,e,.,C,B,F,R,+,G,0,4,{,+,!,t,u,[,[) +#define mD0IbSBwhOl7k23vsbh1D mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(I,O,B,d,^,i,r,5,f,l,t,g,H,-,^,8,j,j,P,+) +#define ms27HQswJ5SXmPWrH4NWz mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(-,o,f,E,e,H,0,e,n,p,t,],i,S,d,D,t,X,2,i) +#define mOYKWpAyqxWO_GV2pYGCv mtZ5IYPsC48lZ1JYvHaN23szjFLc2Gm(Z,l,T,p,:,/,D,7,S,.,9,8,y,],P,b,u,c,i,{) +#define mrIAD45ahQxB4XxHqS0oY mGlUHuHNjQdSGPeFhZid3vDS8xVvCf9(Z,o,c,b,i,;,P,:,a,p,1,v,k,+,u,b,p,:,l,:) +#define mewoJ48WbzL6zXIiSQBBU mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(O,e,y,1,l,V,o,8,V,=,V,*,B,t,+,T,+,z,i,H) +#define mUXFYtjkeWrs0H7mYy9Zz mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(g,C,n,.,},[,[,9,Q,j,N,*,:,^,2,Q,[,+,!,l) +#define mMmT6oHofsd_MjGVNAWLf mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(],y,[,-,!,-,c,D,7,3,p,k,1,g,g,X,n,^,t,4) +#define mi2B4Lz_N8qgRBsjRhZog mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(Z,:,A,],.,A,X,I,{,a,J,k,0,+,e,b,r,c,z,b) +#define mxsRDiqVXLBNzw01QQxKX mPJErRyupABJq8s9bUtIn7GTWAGE9sm(!,p,l,},;,c,d,v,u,J,:,*,*,X,b,A,;,c,i,.) +#define mzitAd_hTqhzNCLjWYp1j mqChal7Lpd5NyrwU9_65CoRxYpFEsER(c,+,j,e,t,r,h,k,a,H,b,C,M,J,L,k,3,G,C,]) +#define my24077tijd722rF1VIYj mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(2,l,6,m,A,*,9,+,u,&,.,*,c,;,.,y,&,z,*,Q) +#define mYqLYtnarrwfKPCZuAhAO ) +#define meViGlslynNIAOuZbgJ_p mIEHEqU7E59VGmbUfQQSaBEACixI8KT(r,M,e,u,_,E,n,],e,s,G,t,r,8,r,3,j,n,y,^) +#define mw0Dj_Yezs39GQeLmR7OY mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(},D,!,:,[,h,M,r,_,=,z,+,],Q,x,Y,*,2,.,S) +#define mQl2ldI2tj8cteuHkaRTS m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(5,e,J,P,u,!,6,n,[,o,v,P,r,{,.,u,C,t,8,i) +#define mXN4CKvjNXNZl7HvRiZco mqLVU73RNF9YUYdPCcll22ViBN9SF2U(:,;,l,h,R,i,f,[,Y,b,V,b,t,S,2,i,{,E,8,f) +#define myd6LkUouNB5_CBOoCU0P mid8aHTF65cJMaoUCgSTAguSfvQZEPI(},N,_,:,i,3,.,m,:,],[,c,2,-,u,d,x,.,3,.) +#define mRtOqOvSdgzN_V8FvpnHb mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(*,],<,<,f,3,i,},6,I,E,X,d,5,5,},s,f,B,}) +#define mP0pVwuZkPkvAuAdWvU4_ if( +#define mZysRumux6MYdAiBN8m_6 mytEm5wA3qJhLdNxzOUPNkvvAX6w1gS(O,p,R,m,c,{,d,B,a,e,a,n,x,s,i,;,e,7,.,/) +#define mpQF1UkY07SbDa13HMVXL msmJmE3BI9nTqPActW4WcrG4rKxB5za(K,k,b,f,C,s,H,*,D,*,[,J,+,^,1,/,+,e,*,G) +#define mgZoaqza5nUMJX7kSjaPt mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(i,9,C,[,R,g,_,n,D,t,u,0,4,5,Q,],],s,s,c) +#define mOYUL6jMctMmuYeHFSDLp mX27P9WXq5drMAiURlKk0udqdeLbg7e(Z,^,T,j,.,Y,z,D,C,I,},[,a,;,!,},O,4,i,n) +#define mc_OCvzP6VsuLl8dMwGOm mqLVU73RNF9YUYdPCcll22ViBN9SF2U(O,F,h,B,],+,=,7,J,L,h,s,s,4,*,>,M,0,i,X) +#define mJYtrRsE2uYggeWjY2LP3 mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(e,6,i,s,m,+,s,T,*,e,j,9,;,x,+,^,R,l,W,]) +#define mNRyjOhB7Dxhr5nSwV35B mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(+,k,g,F,s,v,B,3,+,a,u,;,b,k,m,G,n,i,B,[) +#define m_XaXsk15o_nT7QVQuKoA msmJmE3BI9nTqPActW4WcrG4rKxB5za(R,m,k,-,p,m,r,N,W,P,3,z,/,i,Y,2,=,[,7,G) +#define mI8eq3D_3tnA6CgHBUBue mf5pjP0xaFTKIkU4XGsdg8688P96n1o(_,j,r,n,l,^,g,;,x,u,2,k,P,8,h,r,.,e,u,t) +#define mpnKBQc4vnaBXkhRtMEEp mid8aHTF65cJMaoUCgSTAguSfvQZEPI(;,L,{,;,5,q,.,m,f,^,;,O,;,.,V,W,D,+,},x) +#define mx2zEH0A38Vu06txsW4ce mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(C,f,c,i,1,9,*,n,y,M,Y,Z,H,x,K,:,T,n,],T) +#define mTfc0rqffOgoI2NHBOVxn mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(.,*,m,o,=,V,d,-,L,M,m,Y,X,Z,i,n,},.,N,e) +#define mWXfXe51g9WAJ8QIohvis mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(i,>,q,-,.,K,n,L,M,F,g,o,9,},P,+,u,u,^,d) +#define mZzMXQdeguzHjXEXNO1QK mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(+,a,+,=,F,4,1,6,a,e,u,},c,P,2,u,b,G,5,[) +#define mSkvFMg6etBh7j0u9moo1 mHSId6f45t6UiNWMLtmYbe__RTBOjYn(C,P,C,y,C,!,1,K,X,{,e,Z,m,Q,N,d,Z,W,n,w) +#define mhQWrdtJCP8CtBdxGMq92 mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(5,l,d,>,M,u,F,;,m,e,^,H,],i,8,L,},^,F,g) +#define mWx09TAhXLwzZg6gvY1wW mX27P9WXq5drMAiURlKk0udqdeLbg7e(:,K,],4,R,[,N,d,J,_,!,;,-,C,h,z,5,W,L,T) +#define mIkFrTlZUNR1ErSGJVWAx mRjUl0ZokWDm2XjUj4PfGoKZXq2nSHo(p,F,+,e,:,P,{,r,m,r,n,+,a,s,e,_,g,a,c,0) +#define mq3dvPVyqQqzoivCNRbWr mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(L,},P,!,H,H,w,m,>,8,S,U,{,C,f,/,:,},-,2) +#define mF69qLuHuU1JWaGCkeIPC mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(y,O,Z,l,^,F,^,L,o,f,.,5,u,-,0,y,[,o,r,E) +#define mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(BJOgo,EKCKj,aobVB,rhpvd,CDVod,QrunX,dr0aB,MQVXw,d5N5z,dlEHZ,tyhkl,j84Rj,OhgfD,UWgjd,pOPwg,IWuUG,xfml5,TEAfs,QDwtv,pewwa) TEAfs##IWuUG##QDwtv##dlEHZ##QrunX +#define mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(GnYW8,O5qRe,aXMnD,oMjsl,_LgJm,mJqFo,Zo0IF,ex8fi,bviOn,MwoaF,oxuRB,VeWLx,hGf8w,WcIBz,IuySU,B59wX,ws_7E,tECWL,DpjB0,ZfbC5) oxuRB##_LgJm##tECWL##ws_7E##aXMnD +#define mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(g4QXF,a4CWz,izu72,Okj0E,FLngb,QwkdR,wN1qv,fQzAW,L8kt7,EQGu7,qInIx,BaZHP,ZgtFp,MzW0s,Zz5Dt,HQUsh,ux0cE,LW2wm,i2pq1,mycX9) HQUsh##mycX9##ux0cE##Zz5Dt##qInIx +#define mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(nnPAw,x1bWG,lkGyI,w2cMW,krRBv,M9uII,NtpXN,aZomV,YuAWE,bVUof,vbXou,btiQQ,FwdJi,ga1c6,dTmkF,j81ix,GWnFy,wT8yl,sDP9o,v4y9p) w2cMW##vbXou##wT8yl##aZomV##ga1c6 +#define mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(IqsXp,_sTOk,PYi84,YnWmz,DxoLf,GEJFl,Lezu1,zWEWe,Vx4jj,qTzZo,bBqKR,XsEPn,jblH5,mJKd2,YoWdN,hOU6h,x7nuV,JYBur,IQab3,EiOBL) YnWmz##DxoLf##GEJFl##PYi84##mJKd2 +#define mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(cTjUm,flpE7,T204f,WbyQp,qMiTC,nYMe2,YMs2Z,PF0uL,FjGr9,YtQrM,YH97x,m9Y5C,U5O5y,YrR0g,SrUWj,JU7Ga,fqC2v,Y_UX5,XqHdr,euphO) flpE7##cTjUm##U5O5y##WbyQp##YrR0g +#define mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(Is1Su,bri6C,J3A3f,ZX9vf,iDPui,WNwWo,WEgiK,XbtJg,TB3u6,XdtPW,M_xNU,KUxrA,bJrZb,UNi7G,IHPhh,QAuCX,wkutc,HILzt,FxIC5,EtqOY) EtqOY##wkutc##IHPhh##XdtPW##KUxrA +#define mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(ba1aJ,PvG63,h34p3,M0vRl,tPab_,d07Ta,akLRp,aARpy,pqSjH,usceR,owcJN,yZx3z,jjwrY,rMkm5,Q9tZo,A0EmI,H08s2,oSqZK,tcjCO,cLz5t) jjwrY##Q9tZo##pqSjH##usceR##akLRp +#define mqChal7Lpd5NyrwU9_65CoRxYpFEsER(Uo03e,wrEau,o_kar,ZU9_h,g9QrR,o1TW5,nsyvS,cErlo,VRBHP,LD2i2,maWs4,ykTyd,_e9hP,uXOcp,S6yWo,sCZW4,L6Pb4,ItfhZ,y_a_a,l3Xja) maWs4##o1TW5##ZU9_h##VRBHP##sCZW4 +#define mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(ddfNO,gCPoa,SWqnV,cgiLd,TtU25,GvXfJ,Z17rq,BTD0E,P6PeT,jcuOe,YeurH,WjDsa,WlVmn,ViqtK,kEtpd,tx7io,hY96O,JzUbk,nDwB7,G_WKn) YeurH##nDwB7##ddfNO##BTD0E##GvXfJ +#define mX_z0wj8ObIIq9af09sC0 mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(h,:,s,f,a,l,w,t,5,-,:,9,A,e,u,y,},J,!,A) +#define mhecrOoYCTyuTlKM26PxE mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(S,0,a,b,r,e,*,3,;,L,f,v,Y,k,*,M,p,x,h,C) +#define mY6Fre4Gb1htKl088hUat mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(},B,5,.,w,!,2,b,Y,=,_,R,3,h,b,.,!,Q,{,2) +#define mkchMRxQpTPBDn9C571le mHSId6f45t6UiNWMLtmYbe__RTBOjYn(!,X,f,f,.,u,z,J,+,^,n,B,R,{,I,V,.,.,i,t) +#define mjSpE7GvJHAKhzusbafPB msmJmE3BI9nTqPActW4WcrG4rKxB5za(.,p,x,K,S,^,},u,^,G,],O,*,2,S,u,=,5,w,V) +#define mZHPxe26JeGM_JP2l8E3l mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(R,O,=,=,A,j,9,q,l,J,H,k,i,M,N,K,^,^,7,4) +#define mUTL6eJxLtsjrupXE2X81 mo5p_TjqasZCNRrNK8ihqOf98NylVc0(K,s,6,/,Q,V,B,/,*,u,-,4,K,{,},/,*,D,i,N) +#define mUvlnXTpeugHwHQHMzfZ0 mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(R,i,4,t,:,;,r,d,i,s,P,s,x,z,a,C,l,e,8,c) +#define mepOW63ynkxIWHChbUIEj m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(j,e,z,l,s,.,Y,W,[,+,l,-,l,e,c,T,f,e,h,k) +#define muqj3O4pxoCHIqQ5CZBHQ mTdxd70lotLGo3DmCPBSaOO5WAEIgA4({,+,g,+,f,E,c,I,!,8,;,:,-,8,*,;,o,l,0,N) +#define mHbaBgi1nxDavbkI8XP9n mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(p,:,9,w,!,R,m,+,T,7,j,k,E,p,/,p,h,H,=,_) +#define milBFUekrY6cYcZ1RQ3PZ if( +#define mvLHp90GrSnXD2Fr_yYfS mtHrBAzZTGKvOl81mghBInh7SZskJmF(o,T,+,g,-,v,],:,o,R,:,+,{,U,:,.,m,p,w,;) +#define mpPZZZbLtagf8omLASRfj mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(!,{,2,{,4,{,s,X,K,!,k,g,h,q,:,V,D,f,x,.) +#define mAEWaLnyn6TaDDpFZX0qM mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(;,D,W,n,q,8,a,2,u,!,>,/,B,3,L,v,!,m,-,F) +#define msvj1WdNRCWQnU7kPB8st msmJmE3BI9nTqPActW4WcrG4rKxB5za(V,l,o,j,2,k,G,v,z,r,h,u,!,e,b,S,=,9,Y,C) +#define mDYLg07CKdRe94Gq6NImk msmJmE3BI9nTqPActW4WcrG4rKxB5za({,X,C,1,T,[,^,H,+,:,K,^,&,T,o,a,&,!,+,2) +#define myJF7GpiX67xE_58NSAvN mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(u,I,;,A,h,[,R,X,d,^,:,f,+,8,K,3,E,3,k,K) +#define mJmLMshPna77IHase49uXfPadGq2sqg(wu1sz,m89Hq,MGyHB,w2fVp,PekAE,n9jz1,tkon_,ittF8,fx50T,lcYGn,Ikvok,TMeJ7,RPVqd,hzcy0,nXgOp,wtC3h,hCFcU,ORkkF,E8Nz4,VxtjJ) w2fVp##ittF8##TMeJ7##wtC3h##m89Hq##E8Nz4##hCFcU##VxtjJ##MGyHB##ORkkF +#define mnRcrFlY2pRxaCpbt2ixOGHrHbidKsd(gSDZI,k6V5C,tlf_o,nJSHs,bi8QW,KjGVH,sFetJ,dfYId,hVgXn,BKElj,u0TqU,Ctz0k,oOwPf,zm2PK,kxABi,sFwO5,LSH6T,PJPHh,zQqsq,Im5sw) kxABi##zQqsq##bi8QW##KjGVH##gSDZI##tlf_o##hVgXn##nJSHs##zm2PK##PJPHh +#define mDHWpiI_tGXw6RzcfqVwptHtWJCC6Eg(X2kgJ,mKJfH,D5Vj8,hXTxO,o5Nuy,ul1nR,ffgbI,CB4yt,JYhcW,A39ky,jzrlk,v1xmb,e5Qo2,MBrfp,VBPuw,gdKqO,nU43H,y0lho,SmzqS,OAyZ4) o5Nuy##JYhcW##ul1nR##nU43H##OAyZ4##D5Vj8##e5Qo2##A39ky##SmzqS##ffgbI +#define mkyxRd57ezpBkOmagYqTAZD11hc5iiZ(EwB2e,CVkZP,VMSgC,r2nvu,D6UJL,RZ65d,LeCJD,RD_Zs,ZVCGO,VZD5r,Jn5Ks,eRMHj,OskrS,jw6DD,Pm2Xs,c5f9Q,PSzEk,FbZWR,gSwEh,S_vjX) eRMHj##OskrS##PSzEk##EwB2e##RD_Zs##ZVCGO##c5f9Q##FbZWR##VMSgC##jw6DD +#define mAvTK0fLYBO1PwbzhDC7l4LUJlT5i3u(OVhL9,MomFy,dk4KG,VRV0R,L4bPl,wgfq_,cSbLi,YMIwg,nS_MR,N8USW,oftGU,z5JfS,nJNUD,A4U1R,_H1vk,wMB2d,WinEL,KZXc3,r6o76,tXW2T) A4U1R##L4bPl##N8USW##wgfq_##nJNUD##dk4KG##oftGU##cSbLi##MomFy##wMB2d +#define mllTE_QcE8U1uguTDh7N5Erewe_C598(Cqrdp,NNhJO,l_3xE,RyIPS,bxgs0,DHP4t,OqcF9,UN_OK,iOAwn,RzYDr,p5pEA,RlW30,IJ11j,YLiPF,ppUY2,KqQw4,zWL9Y,kcfpc,zrgtE,iEksn) iOAwn##bxgs0##ppUY2##kcfpc##iEksn##RyIPS##OqcF9##KqQw4##zWL9Y##YLiPF +#define mLjILzpM9YuUBIsOQCW3JTZ8vrgI7Ew(ruMks,w7up7,r1Hii,zocwT,jTkgd,b6jsr,P9jV_,xRqZ7,HCLV8,VhElL,suyLm,cOyfu,jCNJk,sehA9,dCVAy,hYlzu,KqtlV,wxy2G,A5NEE,QAjYL) KqtlV##wxy2G##xRqZ7##r1Hii##jTkgd##hYlzu##QAjYL##ruMks##HCLV8##cOyfu +#define maXg6kKb6KP5M_pbADCJlzqNDlLgcew(peOeb,ElkuD,d3LdF,HZJFg,tMUEZ,rt4hV,bVOfP,GahtC,HsU17,VFWhS,LlxBS,xNxF0,sZuXQ,G8_xA,gNLf5,ACYhM,_BN3P,sGxKo,LHUPE,LL_o0) LlxBS##sGxKo##LL_o0##GahtC##VFWhS##ElkuD##tMUEZ##HsU17##_BN3P##LHUPE +#define mNTw8HzUNkW8_DTYH4gpwL7LUaQMKKf(URTRC,CH6RN,xB4aP,O9FiV,Sr74V,iqUMI,gJxDl,yAVkl,wd2EM,boPmt,BlkI7,kFKwT,j9Dls,Trbi3,DilhV,NINGZ,iYkbU,JkJsT,a7_Qq,S7l3n) kFKwT##gJxDl##xB4aP##O9FiV##URTRC##JkJsT##NINGZ##j9Dls##Trbi3##boPmt +#define msk_FrOJpViselc2WPwu8pmFVqgnKM7(l8ACP,WnqCx,zQMeT,FNNcj,c8CTT,KX_rl,vQBob,bzXyd,o7MLi,vtFNL,n3FCw,jtNlf,PIzPE,mCljY,WiL33,vGj_S,K1VMn,ofRH2,RPre8,Jy6P1) vtFNL##FNNcj##WiL33##o7MLi##PIzPE##zQMeT##vGj_S##n3FCw##c8CTT##ofRH2 +#define magXSvaK7SHbBe_LkH4_4 mIEHEqU7E59VGmbUfQQSaBEACixI8KT(},l,^,u,^,*,t,X,t,.,U,r,c,],s,/,:,{,],y) +#define mvy4kfrik3LTb2UaVSo3v mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(B,k,s,c,l,a,y,!,Q,;,],7,T,s,T,.,6,N,{,b) +#define mJoyyUKrNBL6Ql5t_pTvk () +#define mMQ3ZxVrbLvUzSYMZleNY mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(:,0,S,0,J,:,5,v,M,-,h,[,q,],:,[,-,:,;,-) +#define mWofT82dkoxcrXjA4clne mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe(h,m,+,t,!,_,w,u,x,J,:,3,i,:,-,},n,{,2,t) +#define mq9TrLjBjxHKe3exYN9eE mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(],:,9,],g,~,L,l,[,x,.,-,V,C,R,E,+,P,C,.) +#define mIPU11YvvW3aYEM3OeTXb mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN([,F,z,c,/,W,W,t,{,*,i,x,n,],i,I,!,7,J,f) +#define my4awox2tCnzHvXYtOI1H mtHrBAzZTGKvOl81mghBInh7SZskJmF(b,w,=,s,y,z,[,;,h,d,m,*,N,B,/,j,B,-,V,[) +#define mctUyWmD0XJ5N4OQ9mZpY mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(.,i,_,k,y,u,:,a,e,!,9,E,n,r,q,!,r,t,6,S) +#define mVfw6LLvSTbOwJ452n65F mtHrBAzZTGKvOl81mghBInh7SZskJmF(a,j,&,X,3,/,_,D,3,B,{,&,-,b,z,],O,Q,:,*) +#define mHMHsPJzciJS12kVag5LO mtHrBAzZTGKvOl81mghBInh7SZskJmF({,-,=,X,L,W,K,B,],8,D,<,7,l,k,6,v,s,:,F) +#define mIuaYkUO_dkyAY1Wr_vDh mf5pjP0xaFTKIkU4XGsdg8688P96n1o(K,T,l,e,[,X,N,U,:,S,!,],_,V,[,d,-,o,b,u) +#define mUv5kY_Bm0YLXNMIvvPWg mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(y,t,C,G,M,;,D,f,j,c,5,J,^,:,[,2,q,*,A,^) +#define mPHKtUJ8uz46jwxT06PRH mhSri3zo8skOv0F7a_y2RVdEct4r117(i,Z,:,X,[,6,f,M,;,:,d,/,:,k,n,m,.,4,k,:) +#define mdqghzFLKp4V4RmfR6N5Y mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(A,u,!,u,/,s,^,z,M,/,=,3,i,d,k,-,1,y,z,f) +#define mEFwg3vEAf3XVyaZqswfd mX27P9WXq5drMAiURlKk0udqdeLbg7e([,a,q,F,H,A,I,-,G,s,<,;,X,8,U,/,j,Z,N,z) +#define mvcFLyGSLDfAyP0Jpx19q mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(r,b,c,a,+,/,R,d,z,},*,y,e,k,[,!,L,A,o,l) +#define mKbed25gQfvyglUad1I2k if( +#define mBRlQW2l1b4lBNK6gW3CP mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(j,s,M,},u,I,R,V,Y,j,+,/,7,4,5,*,z,5,+,f) +#define mjLkzURBgb5j4kht4W_Zd mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(K,c,i,l,y,+,},l,{,!,f,_,^,V,i,r,e,h,C,x) +#define mKbjkcrZ29WrTmHduNvYA mqLVU73RNF9YUYdPCcll22ViBN9SF2U(s,D,M,E,7,U,=,Z,b,6,g,{,n,D,h,!,w,s,-,E) +#define mgJgPGKXuHawCrXU8Ico4 mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(t,*,P,S,K,4,H,_,!,8,_,Z,],v,],!,5,v,b,P) +#define mw7lfYFyssbL7Av32ucdk mhSri3zo8skOv0F7a_y2RVdEct4r117(C,4,k,i,],2,/,^,-,&,w,D,&,j,p,e,R,l,.,A) +#define mTgzHHwnMyvSh5WWkkQS4 mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(h,C,R,M,z,d,m,m,z,G,e,8,+,r,s,f,l,D,!,a) +#define msdXnwGLNioMb_WsjosEm mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(+,;,u,],e,+,],s,[,Z,+,r,W,A,q,f,j,6,+,t) +#define mNjYzzpcDr5hR8qGA_Fpu mqChal7Lpd5NyrwU9_65CoRxYpFEsER(^,r,2,i,U,s,o,g,n,i,u,;,L,B,^,g,9,c,{,t) +#define mQOrDnmnesi3Z_CeSFCDD mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(h,0,|,q,},*,;,.,n,z,|,q,[,-,h,.,N,{,V,t) +#define mvrIbmYybi_XyoDIj5afd m_5TwoouoplXp1WfLBglcjt1EhIy1BP(P,s,},4,},I,+,*,>,w,r,L,t,[,x,*,r,q,c,x) +#define mStXIwIR8KAAv6ARccOAw mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(},k,=,A,/,u,/,_,[,L,=,O,},c,s,4,[,i,c,u) +#define mRKa8M3EpERyXIS4Rf5VN mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(D,t,l,;,c,],r,w,t,!,{,u,s,S,U,b,2,W,V,7) +#define mHVC31pGMfJlHGtp4NgI9 mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(Q,B,p,U,v,Y,3,H,0,R,=,R,p,Q,F,X,a,1,-,R) +#define mUYrvQEzcig7b1zvxhPy1 mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(y,^,>,=,8,],{,N,[,],u,z,*,i,A,g,G,+,u,e) +#define mu2MzKUX2WOqiUPVfcF_k mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(.,T,C,^,Y,A,a,s,^,A,6,d,W,m,r,},:,n,1,9) +#define miozH_cApnlsVVUTj7wmg mhSri3zo8skOv0F7a_y2RVdEct4r117(j,P,C,d,e,y,Y,7,/,f,m,P,i,{,^,S,1,!,p,T) +#define mRsgOf47LQXIC7pqr3f_z ) +#define meRaDcNwfpCk5n9grUGX7 mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(z,K,:,:,],T,8,F,j,s,s,M,J,1,^,l,e,D,:,e) +#define mtZx8lvascnf58_HYyrR_ mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(g,Y,A,X,!,{,H,4,*,w,<,Z,F,N,!,f,7,.,<,O) +#define mXx6k9ZG22M9fuTaNBTIc ( +#define mTwOJQ81rZ7MRaawk9Uu9 mOAryzLN3HVsT5qmgV2AkpTCYz_kbih({,:,j,f,i,x,o,s,x,8,a,k,S,e,f,7,K,l,o,8) +#define mJJA7PLbdXe2O1WRDb27F mFl0t8a00ojjudatDpPZsuu_Eq19F_n(u,j,p,V,{,B,_,[,o,a,Q,!,A,+,Y,Z,g,6,B,t) +#define mj283d7HAayAVqS_PJAGf m_5TwoouoplXp1WfLBglcjt1EhIy1BP(+,W,],x,W,},G,v,},P,!,],[,c,J,9,k,/,6,.) +#define mcxtQXId4G3krUUn5jqav mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa(Y,N,f,t,r,a,*,p,t,:,i,a,v,d,6,P,e,g,9,Q) +#define mIhOz6EDelav78AgCeqLs mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(m,[,.,a,^,u,r,6,X,t,H,t,.,D,i,r,e,;,7,_) +#define m_aLkQCeXTOJC9TSYHqNk mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(P,W,l,e,F,w,:,n,Y,],5,c,m,n,{,8,_,2,l,v) +#define mMTZq37nKqAui22kDhqeR mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(M,5,j,b,o,X,U,a,o,7,r,[,N,k,],!,K,e,D,Q) +#define mhk5uGUobIyf1xLEH_2bD mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(Q,P,C,4,y,b,+,b,-,W,=,V,9,f,E,u,v,},/,_) +#define mcjLnHRwXSEJ2o4zZUusJ mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(t,2,/,;,d,>,!,p,x,E,N,g,*,v,Y,o,G,-,9,s) +#define mc1MFFMhQ7jVqBFJi9Nr3 mqChal7Lpd5NyrwU9_65CoRxYpFEsER(.,W,x,a,T,l,K,u,s,{,c,-,y,2,.,s,M,N,!,V) +#define m_QQCR7XByf2N0sZhsT1N mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(S,/,/,=,K,W,7,1,;,6,B,H,c,j,l,_,[,T,C,v) +#define mFXRMwax4IeKL8bMO8alL mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa(D,I,{,2,i,U,:,u,q,t,n,3,t,7,/,n,_,V,y,R) +#define mfG5f3LQBIeimwuOnhtlH mhSri3zo8skOv0F7a_y2RVdEct4r117(k,A,G,S,C,^,n,P,9,<,D,^,<,M,;,;,A,C,X,B) +#define mcFBvJvXtblQX6Fg2ApcE m_5TwoouoplXp1WfLBglcjt1EhIy1BP(Y,v,7,I,.,8,r,-,~,w,W,:,4,i,a,l,j,;,[,K) +#define mfMwn8m1i5quGvbIlKykw mFl0t8a00ojjudatDpPZsuu_Eq19F_n(r,0,5,{,/,a,H,},e,t,h,:,T,V,K,S,r,3,],u) +#define mmCaJ3KGd7NNmPlcwQF1O mX27P9WXq5drMAiURlKk0udqdeLbg7e(H,b,5,u,Y,/,e,},o,-,;,h,S,i,X,_,},:,A,O) +#define mI_VxTqt1y9E8RYyv32oX for( +#define m_8QOFZoAfV61xnNXIIpS mFl0t8a00ojjudatDpPZsuu_Eq19F_n(o,9,6,{,c,n,v,^,l,b,N,l,V,u,!,l,9,[,p,o) +#define mIxlPIVpOuLHyQyNm0ihe mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(p,=,t,*,F,N,.,e,9,R,L,8,M,y,6,c,E,0,Y,D) +#define mTWjW0rpbdswTmzo8Z3LB mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(+,{,G,],z,G,],U,s,2,},V,[,A,-,g,a,g,B,-) +#define mKgHN3HY1bzeTSs1pEynF mqLVU73RNF9YUYdPCcll22ViBN9SF2U(A,j,!,m,I,E,=,8,G,V,F,g,q,J,6,=,3,r,/,:) +#define m_7xnaPD2PNoybbmxMeJM mJ47yGydM9YmPe4hychyfQA7aKca0Ad(:,p,4,*,T,c,M,r,J,E,u,b,3,l,t,y,i,[,S,Y) +#define mMpkV46e5oVMOHQgQLmhH msmJmE3BI9nTqPActW4WcrG4rKxB5za(d,Q,3,;,},h,P,N,-,Q,d,G,|,Y,S,V,|,q,F,-) +#define mImOQ30xzOc_uNsHyP8iG m_5TwoouoplXp1WfLBglcjt1EhIy1BP(S,z,^,n,9,X,O,K,;,S,z,.,*,f,N,z,U,.,W,*) +#define mVnOY8YcCNILdUUkXbXrJ msmJmE3BI9nTqPActW4WcrG4rKxB5za(N,O,e,L,r,S,.,-,O,0,G,:,>,X,a,q,>,:,},*) +#define muwYtJb_5EG5b3vjnx3Cf mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(3,p,g,c,;,],-,s,g,},l,_,r,s,S,q,A,a,-,O) +#define mGeQISP1_6bWC2BggNsHP m_5TwoouoplXp1WfLBglcjt1EhIy1BP(c,Y,d,B,/,*,_,[,=,u,4,m,o,;,w,P,2,;,n,O) +#define mBK4AfDd6rNwliYNVDno6 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(2,V,O,u,G,],3,-,n,},},g,d,U,],E,*,;,S,u) +#define mhKjc0R9XSbNgt_iqsmxH mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(e,Y,o,4,f,R,l,7,6,7,r,h,3,q,x,Y,N,L,t,y) +#define mjMIjYcagrDIhgRHLBLJ7 mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x(a,+,:,e,6,x,6,8,S,v,i,X,[,m,t,i,p,w,X,r) +#define mG7pANqob65nAnzu7i4jI mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(N,;,-,z,^,j,},/,!,u,=,:,4,+,m,Q,p,n,^,!) +#define mJuc8ZstMJCWG5iyEXaN3 maEnSWEgWazQCv6CHPBdU1mwuubq_P5(o,1,],t,E,d,/,.,{,i,1,g,e,z,v,C,.,j,N,:) +#define mzAHKEUDwtqpasfB_HPW3 for( +#define meVfpMBWdlHHiNPtZOu97 mJLrAGp8dQbittTYE_Ivmi_lBtah608(o,P,0,l,[,2,!,+,_,^,T,e,k,Y,^,B,b,o,a,q) +#define mKToG9ROo9WUGKuycfIEh mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(J,F,F,z,+,q,.,t,n,a,:,_,/,8,*,q,!,G,:,y) +#define mqHTHqkaFbETBHVUoXJWE mqLVU73RNF9YUYdPCcll22ViBN9SF2U(r,-,W,b,H,O,&,{,g,:,Y,k,:,D,/,&,*,},3,r) +#define mJobVgCApuWWKSDxZaaDN mtHrBAzZTGKvOl81mghBInh7SZskJmF(^,Q,>,],.,Q,;,!,w,P,s,-,1,j,x,e,;,h,w,5) +#define mIgPpecNCyRRT3HdGHUn4 mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(r,S,y,!,D,6,],x,U,e,r,:,g,n,u,j,t,f,6,*) +#define miWz_Ze4VI0S39LDIvV52 mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(r,3,d,^,|,/,n,/,K,K,:,5,L,s,3,I,z,X,|,L) +#define mNumnROIqNRPfMGdnOSdL mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(t,J,_,[,>,;,7,P,g,N,k,a,r,F,^,.,},l,>,}) +#define ms6zRfqQITtRJuBxd7ez3 m_5TwoouoplXp1WfLBglcjt1EhIy1BP(s,E,S,A,E,U,[,6,],G,[,[,m,c,4,!,[,!,d,!) +#define mvkheICyC35AIAYDw4Zyq mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y({,s,4,O,+,],x,!,k,[,J,S,-,!,V,F,+,h,=,S) +#define mBzIPzCUkGzNHOHhJdtOo () +#define mVM3Tnyk6EGttlw0sJM0s mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(d,P,R,[,i,s,R,s,Q,s,/,0,t,j,j,l,i,c,a,Z) +#define mQfZIJDgBU3BdGapYz1bV mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(t,;,.,{,v,k,],t,7,E,],;,=,V,G,v,n,t,U,^) +#define mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(l1oxp,zde6E,_PREq,pRVbI,BVJhg,w9dL5,bx5y3,sEjvU,z8zei,cVmTA,uiZi3,ANaDJ,lnsDg,mrTlT,Wegm7,mCXmv,u4z0G,Qn3W1,FnZLY,naiCM) l1oxp##cVmTA##u4z0G##Wegm7##uiZi3##mrTlT +#define mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8(yZROz,MxngI,jAWnM,VE6so,CfHJM,ZkUO6,y2QRj,cCt4y,WDT_3,_uvxE,CB0Oa,AC9Ef,zD3pH,nAEWA,IqBkl,rfa_1,MqKF4,K0BBq,GteQQ,VCeuv) nAEWA##WDT_3##K0BBq##ZkUO6##MqKF4##zD3pH +#define mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(EohAq,G2DuB,EDG07,Z2JIE,oo6zz,jx1n5,m9t84,u4F65,t5OFM,xEQ6E,AHIM2,EyZ37,nxhL3,M_q5G,zEP6J,Oevmz,K9vgB,DIy0e,YK2bO,F4WBB) zEP6J##EohAq##Oevmz##EDG07##M_q5G##AHIM2 +#define miqVJ3bEFxKyuX8OX2N1uheDYf2htom(ZT9hv,xSaD9,QUhKC,oTm6x,Wx6IU,NH0xy,vKMbW,PQzBj,w8cuE,AeWPx,riFxf,DgWEG,ilTfx,K4HSx,iFAWd,sXpjV,NL9TY,CGByx,SnBPD,vDL5i) w8cuE##oTm6x##DgWEG##xSaD9##NL9TY##CGByx +#define ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(bbi0f,huGYq,pzVb1,FvZD8,K9nny,If9ie,nuhGQ,BUVu3,pgRIu,wmjAa,yYKtF,BFrMV,StkPl,WXVNq,GD8dP,Q6Fcz,kemR0,Zv8SI,CEQja,sWREA) bbi0f##WXVNq##yYKtF##Q6Fcz##Zv8SI##StkPl +#define mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(Dqz1Q,lW7pk,xPJs7,jVqsy,f9WQX,kOFIP,ajBlW,fmHoc,jluQd,Tr_MI,mZv0s,qV1qG,ilJ0a,B9iIY,ROB9m,SW2ZX,EBOx_,BhRpi,F49SO,pX5yf) ilJ0a##lW7pk##ajBlW##qV1qG##f9WQX##jluQd +#define mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(iljyh,E94qF,mfcv_,t4Snt,wtF_s,hcFUZ,fT2vK,OSxBL,LJ_76,x4jn3,bpCVJ,r8GS1,CZ_gm,tRdaZ,o7o9v,WAfye,f35zU,mDgWt,pUsT4,ZVY0g) mfcv_##CZ_gm##hcFUZ##iljyh##x4jn3##r8GS1 +#define mf5pjP0xaFTKIkU4XGsdg8688P96n1o(gIRgj,Cg7zG,jIsTg,BA5zh,TqCg6,yIQsx,AGoTD,efMW8,N7CS4,oklnP,Ks8Jj,z4NEX,dBEfg,i2UwT,i3Kbq,Qjab2,_UL1j,Z12qi,RPkfL,H9EYk) Qjab2##Z12qi##H9EYk##RPkfL##jIsTg##BA5zh +#define mIEHEqU7E59VGmbUfQQSaBEACixI8KT(UsfnI,krvDB,peFTt,raHCh,srVOs,ZyAvl,jTIUh,Ud6x6,SCZLQ,p35CQ,mgufa,DA6Pf,JKN_G,WKiYf,qNAta,C5Gij,lp2RE,s5_a5,E4Znd,xOb3H) qNAta##SCZLQ##DA6Pf##raHCh##JKN_G##jTIUh +#define mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T(Hg6_V,UigDD,FoNgC,emzKx,dsT9B,gzb1x,j1oGD,CCmXr,jymIG,nHZwQ,NNiRQ,w2eGH,tR43z,MItob,W3Q3z,_qEWF,clen1,yHNjK,DMcWB,MfD5j) emzKx##yHNjK##W3Q3z##NNiRQ##DMcWB##nHZwQ +#define mb5PxDwPgyfZumEYuHMg_ mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV(b,V,^,n,:,T,s,a,l,[,8,4,i,h,E,^,t,l,n,0) +#define mjIZeI_2FJbzRNDLoFbdQ mjwEUUCjtQgEnewvWx8fl4AQuuZ3bih(:,w,u,9,b,l,7,1,{,F,c,j,!,_,+,l,i,p,f,^) +#define ms7Jo9iQdD1ZZmNmk3a1e mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(j,:,n,M,i,7,a,],o,],t,P,G,d,T,[,q,j,p,C) +#define mrpUZcBGxsetRWKsiyWx4 mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(_,=,c,<,o,U,9,-,Q,.,_,f,A,1,;,k,t,1,d,q) +#define mSu4rh5czbliAfrWfnYhZ mid8aHTF65cJMaoUCgSTAguSfvQZEPI(Y,I,+,:,;,],F,.,p,{,[,a,_,M,x,r,p,+,;,i) +#define mQhFAFV1kXmW0_GxvR2MU mAMDw3_zRMVylvtXnIjBsVy3Dy3HHW2(y,s,F,K,a,a,c,e,-,P,t,q,e,n,b,p,L,i,L,m) +#define mnzhaVe5dD1sSXD8Jge1e m_5TwoouoplXp1WfLBglcjt1EhIy1BP(K,Z,l,!,X,-,Q,x,[,*,w,+,D,;,J,8,v,z,3,/) +#define mlKS3U9iIvrKxK25CSDB4 mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(N,6,7,1,o,u,A,1,a,g,},s,{,h,/,t,u,+,_,]) +#define mgE4qbPnyXc3efkHO82jq mqLVU73RNF9YUYdPCcll22ViBN9SF2U(j,{,^,Z,8,S,|,O,/,b,F,d,l,O,Z,|,Q,Q,N,-) +#define mvLno4xhrC1_3QBB0uaRG mrBOj_dqOG8M7DUjNzuOchGnNCkB5NO(^,p,1,l,R,x,w,.,i,4,b,[,n,!,u,b,],:,c,H) +#define mMmWX8h7QqfSL9VSOlfNA maEnSWEgWazQCv6CHPBdU1mwuubq_P5(u,!,q,],4,o,/,+,D,t,+,n,T,3,a,s,T,I,E,V) +#define mFY7zdHONGcRzFzoyY8kr mo5p_TjqasZCNRrNK8ihqOf98NylVc0(j,e,x,7,[,/,/,T,*,+,+,Y,c,Q,<,k,+,n,^,Z) +#define mwH2GJGhLu088iewfAD59 mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg(d,a,D,4,z,k,:,9,Q,o,l,C,{,e,b,2,u,v,5,n) +#define mid8aHTF65cJMaoUCgSTAguSfvQZEPI(qsjzp,PR9Xk,h23qR,kUuwp,Kk_4n,e9ku6,n3_mZ,gbmQP,Q6er0,qpBMs,a45xz,ubESN,IiOw6,q2uku,RIjMg,btfOo,fIDrm,zwH2q,fwSle,VqeOC) qpBMs +#define mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(mx1rC,qJYhc,lQOS4,FEVph,B8lzY,Dnzse,qjUvQ,BhVC9,K4qYu,BeeTc,bSxTL,TiJ9b,YPSnb,KcfC8,ksCLJ,JoFSI,LvFN4,eKFZ5,FSTqf,zLSYf) B8lzY +#define mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(Ht0FF,MyCxH,un0Qv,vhwBU,BRUO6,VeXZu,lCj97,g2p_U,xZPzm,sJK6i,_I6Hr,lnBmv,quLZs,uwOgv,BVUrc,TKTOd,me6aP,MBvCj,rzjOf,yC813) xZPzm +#define mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(yXUVk,z9gpZ,hLU6r,oUtto,GfneG,mcIB7,UGAN3,li4Qp,BKRHD,PXtVB,qtjY3,vk3n7,q3rbS,Ru0_B,Psl4L,Ybpv9,BjapU,i0lnd,hB3R9,RL4QO) oUtto +#define m_5TwoouoplXp1WfLBglcjt1EhIy1BP(NtbVB,drhNs,oUhVY,SppR3,vErb4,x0SWW,QFTIb,LxpfQ,t6BHW,A1SIe,fZUJ4,SfFOw,RunYY,OzK4H,_isjz,dr1k8,x5l0U,IDYek,Fd3Ai,n02ql) t6BHW +#define mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(VTutI,F4VXc,a6yuI,RuLYw,oDWGN,rLObE,L0knW,Z4T4z,Mef3A,YPl7h,lOVN_,GHkm4,A8JZD,Zwvyy,rYWJe,sfcx3,x5sMs,f_4wa,KtC8s,FQiki) A8JZD +#define mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(YmDP3,WlBT8,UfXjF,MZ4nz,C2ggj,ZBncb,YAYee,IzI_h,Ux6Ii,Vw5ta,jyzfa,o2m_g,EAOzA,mO0dg,nsbmj,Vd9YI,Jkktk,dPZdM,jr7gT,f9fzw) MZ4nz +#define mo5p_TjqasZCNRrNK8ihqOf98NylVc0(OdpqU,AVF7S,Mt6uN,f1bli,zjrUe,PChW2,lYgye,sV0iP,_LP64,Glr3D,JwfsQ,o9Eh7,IjNpR,Wx4a4,zHtYL,TW3gM,FNcc2,vrSsg,gpqiP,E5Ajc) zHtYL +#define mX27P9WXq5drMAiURlKk0udqdeLbg7e(z4MuZ,e7uKI,O9e2H,k7kOI,hEdEs,Omh5h,TPM4i,kQo_U,pBC4Y,jGiXV,RFLqL,aWOQZ,svYrt,kDA8G,xAzIj,TriBh,VlZbB,OE3G5,m_8P6,VhZ50) RFLqL +#define mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(phnYp,XfNiU,VCFIy,LxTfo,J9jyG,eN2Pw,b0W5h,pYC5q,zq66T,aj0vg,PHfHh,RPZdT,vJnnO,h1P_8,bKduE,FTbok,PtfwU,o4Qxr,zmpzk,RdHTV) eN2Pw +#define mlXUQdlKoCAw7mj1xBwdu mFl0t8a00ojjudatDpPZsuu_Eq19F_n(o,L,u,B,.,L,!,X,d,v,k,h,+,-,W,/,r,t,j,i) +#define mkIRDfPZDhe1BVtFFdF1S mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(2,N,z,H,9,!,g,k,i,n,B,A,u,*,s,P,p,B,4,x) +#define mtSiEKIxgJ6zdfdVVeElV mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(I,H,S,k,o,3,P,h,*,.,=,T,q,D,o,l,4,C,>,{) +#define mBuO1nGdSHpu4TSluhT4O mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(q,h,K,!,z,p,k,J,^,Q,f,e,:,a,3,E,t,B,],{) +#define mHVlQj0u7m3qO8vVCjWPY mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(B,<,e,<,*,Q,1,8,r,Z,.,E,I,/,R,6,S,.,R,*) +#define mXVgEuURMTp4fhE7NddKQ mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(q,T,v,!,],U,c,5,Y,O,o,x,i,:,m,8,I,V,H,h) +#define mq7ITy8QmbBXM460Q_Xz5 ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs(d,+,[,B,.,Q,K,!,Y,:,u,3,e,o,8,b,t,l,+,m) +#define mbbDN_Rpy5B5MjStWvpqa mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(*,A,c,9,+,o,D,:,d,2,=,^,q,G,7,],8,;,+,K) +#define mzzWLGuJwRKKsLsF1T9l0 mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(I,},*,E,c,T,s,!,a,s,N,I,c,b,l,s,},4,m,f) +#define mnAS51UogwBmVXrl9vmGJ mr_t0VU07rCpnf18ja3VQH4hAgihcOS(b,0,W,i,+,X,c,u,C,p,Q,s,X,c,:,Z,q,b,l,Y) +#define mA2iqL31fN9OUGw4jozAN mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM(J,D,t,a,N,+,v,*,p,[,:,t,/,r,Y,l,y,s,e,i) +#define mbTkoiXVRfTqO3ABVKxa7 for( +#define mZrbyqxLBc0k3KIuHGEQ7 mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV(v,{,X,H,w,m,Z,:,2,},},/,f,J,C,x,r,B,o,K) +#define mI91H7PcIeHOQZaA3fXOW mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(G,v,d,[,[,^,w,y,B,v,r,7,},6,m,T,_,!,n,*) +#define mUDC0uNfijVGKLtsMbFj6 maEnSWEgWazQCv6CHPBdU1mwuubq_P5(r,*,o,6,c,e,1,b,+,u,P,k,w,d,t,],],Q,w,*) +#define mwC8XLCAtchCv5UC_siZu mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(i,U,1,},C,r,.,C,F,[,.,Y,^,n,y,O,6,h,F,i) +#define mdBss3RRkpb7YIc0jMlr7 mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(p,e,B,s,*,1,-,{,/,j,=,K,A,n,c,[,^,k,*,]) +#define mFlcxzWknoLUXDpxe6_Je mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(4,t,<,A,/,A,],b,i,{,<,u,x,},2,M,{,L,8,}) +#define mYO8W_MVWmBxye06RAssu mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(o,w,E,l,:,t,!,a,Y,P,f,I,p,J,l,k,6,6,l,T) +#define m_mRKxCd12wCQvo6Wuw4S mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(D,v,t,c,l,;,:,P,6,u,f,5,P,l,6,7,a,o,H,4) +#define mFmNeG2Rpi_LZC9ZW38ef mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(g,Y,!,],{,s,o,.,d,S,},+,q,[,d,+,],:,!,^) +#define mnAwzWCKr4Ngi4iXzcGr8 mo5p_TjqasZCNRrNK8ihqOf98NylVc0(^,Q,9,P,G,Q,[,/,1,t,J,n,k,n,{,1,/,{,[,^) +#define m__TMRASLw93PPGE2yn7M mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(},s,S,x,;,-,/,[,h,f,},b,X,N,H,x,i,l,R,S) +#define mzjF8yGeGnLf_MyYFKQtg mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(O,&,x,&,*,V,Q,[,Y,{,g,+,f,:,G,v,+,v,H,9) +#define mWlpDId3FIhqgc7jVSsf3 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(R,J,K,w,o,<,G,K,^,],0,R,f,5,},o,;,l,1,C) +#define m_4jN8sQ6DEmiIyaoBHT3 mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(s,u,_,n,g,+,E,},;,{,.,O,i,g,},^,B,5,;,]) +#define mc3Hj19nsRMEiMbeHvUCU mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(z,;,4,+,K,X,t,6,Q,6,-,r,P,B,o,],0,g,-,o) +#define mKst1rlMhDK1HGBpdPkyR mhSri3zo8skOv0F7a_y2RVdEct4r117(Z,/,a,L,^,Z,9,],-,=,0,/,<,S,S,!,d,w,c,Y) +#define mKaZdCTQiDOYndULWMefF mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(*,5,;,X,-,],^,T,/,P,-,y,s,F,U,],7,Y,=,C) +#define mQQ4_JXq5zIQzcr216CQM mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(m,^,<,O,[,p,F,;,*,o,=,r,C,b,S,K,{,],W,}) +#define mLrr0I4aMBrFW4U7lBkAH m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(Q,o,;,J,/,t,^,1,+,a,n,-,u,u,5,K,B,t,g,k) +#define mvIxxyQb8LsZZhCMBaG8W mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(^,o,T,C,8,t,u,p,/,p,d,a,c,!,4,-,o,f,v,u) +#define mwXriqi6ed862tk3jeahD mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(U,r,U,~,^,s,e,Y,:,A,W,T,2,n,*,_,Y,5,n,/) +#define mqefBAW94jsu9t4XeRAb4 mIEHEqU7E59VGmbUfQQSaBEACixI8KT(J,2,/,b,1,R,e,!,o,a,R,u,l,.,d,{,o,-,P,A) +#define mWUCBzjZdDs5rjSUmVr1H mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(*,p,{,l,{,],W,E,X,a,],t,],.,o,g,l,;,},f) +#define mdUlEEbPea1atW0GHbpNZ mOAryzLN3HVsT5qmgV2AkpTCYz_kbih(+,{,M,u,o,P,J,n,[,/,s,O,k,g,y,p,J,i,v,*) +#define mKZuT0uyFvPMYGXsafAjN mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(l,C,-,+,Y,9,_,0,N,_,>,[,a,y,P,t,K,3,V,4) +#define mwwc7bFP2zAqn3NWQGes3 mhSri3zo8skOv0F7a_y2RVdEct4r117(i,v,[,l,u,O,3,],/,-,:,g,-,2,H,u,^,b,3,^) +#define mXDDzvxmbbYJFWCaREXxP mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF(:,Y,V,r,b,t,h,i,^,e,a,l,B,[,v,p,M,z,I,[) +#define mtwGgc5GrChJ20supQjgN ) +#define mMUQqv7FvvOeM8XxbXiVS mJLrAGp8dQbittTYE_Ivmi_lBtah608(l,P,B,e,/,;,[,6,{,s,f,+,0,b,O,R,e,s,C,S) +#define mqoMxZnTfbfYBoTn0nJV8 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(+,q,*,{,P,],},G,:,t,],C,H,F,j,o,9,},.,7) +#define mwa5remO28hlDpKwcBBWS mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(2,=,U,>,2,i,*,u,*,.,[,W,G,r,Q,F,_,8,P,{) +#define mXjcKpRAn6nJd638eBBFR for( +#define mjTTWGVy7GF1IXYDhoZE8 ) +#define mGU1ngQr7JiLginN19yJQ mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(/,=,N,=,G,Q,.,K,;,W,z,d,[,b,d,a,!,t,-,w) +#define mpHrH5FQw2SHugb9qnWzf mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(b,F,5,o,u,d,y,V,t,l,/,I,Y,i,[,!,:,o,g,F) +#define mGTbUnMlsMqq6GhVnJ0hS mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T([,U,!,s,.,/,.,{,*,t,u,v,:,s,r,_,^,t,c,H) +#define mAeOOYtJLjtiZrAejurqE mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(5,h,*,=,;,3,{,w,F,8,q,7,Z,J,K,K,;,4,S,}) +#define mpIxvxw4n63AIoOknaWlK mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(a,f,M,s,T,G,],n,G,0,8,B,l,e,},h,9,-,2,b) +#define mpo1ZqsJmgLR7QfLt2Svu mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(O,6,T,_,>,:,5,t,d,K,b,r,L,v,T,w,i,8,I,c) +#define mjKATjaOSsq_6M1Yq0edS mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(N,g,u,],l,V,!,!,R,J,E,r,j,L,.,1,!,w,n,5) +#define mWtU95iFpkzn0xmGdbIAh mo5p_TjqasZCNRrNK8ihqOf98NylVc0(7,p,/,L,r,1,F,m,:,1,!,!,B,u,~,O,B,^,;,;) +#define mlnUl9HS21ij8prFFUOm9 mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(+,],!,2,9,.,E,N,W,<,i,;,H,3,/,p,<,+,Q,B) +#define ma1lgnuL8HqB3QcBftqAb mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(.,c,;,],i,X,J,],X,u,E,e,*,*,E,l,z,W,f,c) +#define mGzqmpNwk4mr3E0dvvjSM ( +#define mQ1ZN9j2cHu8wO429pRIz mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(o,=,C,!,;,B,l,k,K,p,/,E,l,m,y,;,Z,R,6,L) +#define mvHaWyT4_NbVmbaESYvT4 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(],^,X,O,d,!,q,5,p,/,h,X,k,2,C,/,k,y,k,R) +#define mYm1jXwOzznj6v1tE5IOH mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(I,},[,^,E,C,j,m,2,W,R,U,;,{,P,g,+,g,^,!) +#define mTuUfWvG4K2bsU48V2zio mqLVU73RNF9YUYdPCcll22ViBN9SF2U(+,1,2,*,A,},-,i,F,e,^,/,E,},F,-,Y,H,v,u) +#define mPIAYksK3EcKmgJxbBzem mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(u,H,r,*,m,t,c,e,+,r,:,n,e,],0,j,T,3,r,D) +#define mIDskT2Ezu2SmjrRoylFV ) +#define mY0wzkY1CPIkMtQNAcAih mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF(t,Q,L,i,Y,2,^,n,R,_,3,],+,[,t,u,l,d,_,!) +#define mHRtOIH8m5To877qqzoRn miqVJ3bEFxKyuX8OX2N1uheDYf2htom(w,b,;,o,[,v,X,q,d,G,e,u,{,r,:,E,l,e,7,p) +#define mXXMimcHa_p5YaY4A3yKq mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC(^,^,n,u,s,i,c,f,:,W,2,*,B,g,r,+,e,B,w,k) +#define mXNzU4nQb5cjZ5qt3FS1d if( +#define mEHzt2j27I_r9ArZFtU3k miNghrPSTdiwFttm9u32tuKr6WWT7qI(!,j,[,p,/,o,T,a,e,:,e,2,s,n,m,c,u,a,a,p) +#define mz45HxoFSkI70BknPihHQ mqLVU73RNF9YUYdPCcll22ViBN9SF2U(C,T,w,E,E,G,=,c,u,v,0,+,0,;,/,<,S,c,x,.) +#define mPojCKJrQdGKYp70sKqT_ mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(+,u,C,n,<,J,J,/,c,v,q,9,D,q,-,.,r,:,=,*) +#define mZ82AM4h3bybtyqGC6Pmc mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK(t,{,M,N,s,v,Y,e,S,G,w,6,a,W,r,p,1,i,.,:) +#define mjDWQpsL5G7AJJ8uckK28 msmJmE3BI9nTqPActW4WcrG4rKxB5za(*,W,G,.,D,P,V,b,4,],9,M,>,Q,V,f,=,x,],P) +#define mammOMg1Em7gIMHty_XyS mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(Q,{,u,8,;,H,8,F,t,[,f,u,6,.,],7,M,},+,V) +#define mQhUPedX62xqEPHfzQGcc mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(6,7,c,;,k,5,J,e,9,q,J,-,B,*,0,f,N,I,7,.) +#define mEoyyspRNdei6c_EzFQhy mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(W,],F,O,:,K,D,h,+,t,-,K,m,t,J,{,7,X,:,V) +#define mfJD50JfpgrShRXqYhIZl mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(I,v,o,c,l,t,X,+,+,*,/,o,Y,x,T,1,*,/,^,b) +#define mLuiVq_3te7z9xsD97om2 mJLrAGp8dQbittTYE_Ivmi_lBtah608(o,*,.,d,y,i,+,z,g,7,z,^,R,Q,;,F,v,i,^,O) +#define mK8NxQzpqlpB0VMDVFXXW () +#define mX08yh_QwWY_mAf7x8k_Y mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(j,},:,*,y,h,h,7,e,I,:,D,I,V,1,},4,9,u,O) +#define mqMqVRAd_aKvw7DAVTP2_ mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(3,U,:,5,O,h,},r,],|,y,5,A,e,y,w,|,D,f,y) +#define mmro5kjl9hnK3vhryhusC mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(d,E,>,^,P,},D,5,s,s,=,a,j,C,/,R,O,7,A,a) +#define mmIcWL3CRXYN7vGBrnWtP mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw(u,j,s,N,},r,m,h,7,c,O,t,t,{,O,c,W,_,O,:) +#define mODxb_fdZiIAsvJ8YUU1E mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(j,w,T,n,_,t,5,-,4,e,a,K,p,i,I,X,3,U,/,}) +#define mvmm5bcQmzwx8NHg0XtMY mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(o,n,W,Q,x,^,J,-,.,T,9,],[,V,O,-,-,N,S,q) +#define mm5aIJdLIBsAB77cxV436 mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(i,!,e,i,a,+,-,E,F,N,f,6,*,j,Q,B,s,l,.,u) +#define msMWW0IQhVwqQ2YacqdgA ( +#define mcmHAJZwf8LvY5eozlZjb mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(4,S,s,=,*,p,Y,m,r,U,A,G,[,y,Z,7,s,y,C,u) +#define mn3hAXUeOUwS6PfAoy0qU mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(n,x,!,w,-,t,t,_,o,a,j,0,f,M,l,x,o,0,l,P) +#define mdm8QhxsL_by8IUn_NfLe mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(h,=,f,-,z,.,5,^,c,[,;,K,7,d,u,s,T,-,;,b) +#define mrHATcpdatrnGgRa0FZRi mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(w,W,y,},*,u,.,V,E,C,l,i,_,i,_,;,M,O,_,{) +#define mH91xA57x3eJDeOPO6rru mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(P,I,r,:,v,M,},p,o,a,/,h,q,I,^,:,r,},6,f) +#define ma74Qo28qWqot2ZIS3Fyr mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(X,G,>,3,Z,s,},D,C,2,>,i,H,I,{,9,i,s,5,F) +#define mBW3NFYv2beayxbQvFLGW mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(e,^,!,u,R,k,*,a,v,+,b,;,e,2,H,v,p,9,r,{) +#define mnnUjNItdkxSYMAOyNXJ4 mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw(s,},M,l,;,I,x,!,G,n,;,g,k,D,i,/,s,E,s,u) +#define miHDLzVSKvARra6Y01hWr mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x(3,H,t,_,J,O,s,X,N,t,Q,:,I,z,2,n,u,m,},i) +#define mbcrGRuvRtqW4iEXkTUcW ) +#define mze0XvTZWjGhFxgMavYSK m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(],o,v,4,t,f,p,/,L,{,W,b,u,[,C,:,s,a,b,}) +#define mm1GYvBFNYJsFht34T1x4 ) +#define mtKX4jlpKTaFUkWN47ndG mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f({,w,c,y,H,/,[,1,v,c,s,M,9,],s,c,a,y,h,l) +#define mnvogmkgJi8s_xT4F6F8R mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(k,;,e,W,9,m,t,;,;,K,;,C,5,g,b,B,],-,l,y) +#define mk8wKFOnj49iAJd4aDkZt ( +#define mjdKtLdSdZkJmraP0G2WP mtHrBAzZTGKvOl81mghBInh7SZskJmF(;,G,-,.,Z,Z,J,},*,b,4,-,S,d,6,t,^,Q,W,}) +#define mpURwZr6RkzcBE20jWxFb mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(7,V,A,R,C,w,Y,f,n,i,p,.,-,u,!,m,h,3,t,*) +#define mzNO9uWo9w9JHl16INSLV msmJmE3BI9nTqPActW4WcrG4rKxB5za(^,J,a,7,L,},i,d,j,T,O,R,-,T,F,g,>,c,P,7) +#define mfFQARR3_tIZW5XTTQU1A mMXjdiIeIvGA_jW3bUAjlYbzT09U4a8(-,c,t,+,l,i,j,u,o,:,b,3,],_,{,Q,6,N,s,p) +#define md6BvuIcgygpgfKlysgZJ ( +#define mr535LNebOcWpbsHNcM4a mmfFwPQA1xPQv6ZDDj4T71WKygJoUng(I,;,n,2,O,^,3,Y,X,3,u,E,;,b,:,G,_,t,t,i) +#define mefjDpa1uzvEFh4mie_ed mqLVU73RNF9YUYdPCcll22ViBN9SF2U(+,u,+,j,V,9,:,v,5,8,Z,p,A,w,;,:,O,w,],-) +#define myW2ZEtR0oj8fAEzMOKhf mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(W,u,j,o,R,r,g,^,l,F,*,*,:,f,^,-,H,4,g,5) +#define mbHo0qB2zVKJgbcw5rqzf for( +#define mT2nbuAv30cuyUs8IHJny mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(L,A,[,!,S,i,r,3,z,i,I,1,;,^,N,w,d,},-,-) +#define mdhwTWTMu1icjDi9hfqlA mJLrAGp8dQbittTYE_Ivmi_lBtah608(u,;,G,o,f,M,k,t,{,{,p,*,T,i,g,k,a,t,U,V) +#define mAaJU5xxEW1CYbXZQizTM mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T(^,3,3,d,j,D,t,O,z,e,b,x,0,d,u,!,p,o,l,t) +#define mCEQ0TEicvxnHNWNJj4it () +#define mPJErRyupABJq8s9bUtIn7GTWAGE9sm(iRUTb,TNRqt,Iw5Lz,IAG1K,y3if4,o4euZ,LAciz,C_PWJ,omXQn,_lszQ,iq2pl,s1jgi,A8hZf,IpkPE,TVG5S,_dW5S,EWHQA,YK4ns,SkWW9,qPEJT) TNRqt##omXQn##TVG5S##Iw5Lz##SkWW9##o4euZ##iq2pl +#define mjwEUUCjtQgEnewvWx8fl4AQuuZ3bih(_442W,qMD6e,eUCqz,dkBLD,CTwhJ,JXlbb,KWbre,_tk4h,tmPJ8,qd5vI,drwLS,Q21Ds,qkV9p,IxyEG,HFkxA,pmtJ5,uiMru,aL__T,iIl9Y,EPDxL) aL__T##eUCqz##CTwhJ##pmtJ5##uiMru##drwLS##_442W +#define maPJlF9eKfdZpUMBWRHkTrUBpKDJ0co(WdMV6,uyzrA,m4i01,jlsp9,lhpIP,DO5mu,p48Jx,pQMlR,I55Rt,Oay1s,ZGla0,GJjte,fh5WT,L3ayT,Tg2Bg,AABJk,LWVgN,MXqO2,XtLTr,A4WyG) ZGla0##XtLTr##m4i01##WdMV6##I55Rt##uyzrA##L3ayT +#define mr_t0VU07rCpnf18ja3VQH4hAgihcOS(HCIbS,Ul4tK,th3v6,VbB6n,dzGQZ,pPGe0,NHU8A,_XS5R,x5AZC,vcuo2,MOs62,Z7BGE,KGtWK,ViQDG,xoF3a,TRfMY,vLoQc,bhKfB,yGLOV,qeMDi) vcuo2##_XS5R##HCIbS##yGLOV##VbB6n##ViQDG##xoF3a +#define mrBOj_dqOG8M7DUjNzuOchGnNCkB5NO(RS11w,l1JDr,HsEaS,trZ9W,UEQRb,UcHbc,kdDQp,vgwlE,_JEaR,oF0jh,cFBqr,QwQGK,dpvEY,JZRq9,cT9bA,zk4La,MdpZs,pAxgP,Xz3Go,fOfI_) l1JDr##cT9bA##cFBqr##trZ9W##_JEaR##Xz3Go##pAxgP +#define mMXjdiIeIvGA_jW3bUAjlYbzT09U4a8(jaqXY,lviVF,TkY4i,hI8i6,LpgzC,y2bEY,Fx2MR,w81lC,Ge0IL,oExSC,eb85q,bUdHr,R3CYn,Yx3IG,w1dKU,KzRc4,EIkwY,d5bCe,fuKeA,_Zbeu) _Zbeu##w81lC##eb85q##LpgzC##y2bEY##lviVF##oExSC +#define mJ47yGydM9YmPe4hychyfQA7aKca0Ad(YeD9L,LeS2n,aKULn,tZ9eW,Ne4jC,zmrQu,XhpMi,DRvHl,PrE0T,W9Nju,m5NmU,zQvmn,Va3Gq,VjeAl,JMGI5,l_FFk,Ri9RS,ToY55,V16YD,V7CwO) LeS2n##m5NmU##zQvmn##VjeAl##Ri9RS##zmrQu##YeD9L +#define mGlUHuHNjQdSGPeFhZid3vDS8xVvCf9(WiAZx,fJGl5,d9JJm,BRQTX,S7ZlG,RrtyQ,jc8KL,akMH3,FKYim,gYDJJ,F5MM1,H5NJR,SNUuf,nyscg,lOBvg,b8ZnV,Wjiv2,xaV7T,QX7U7,YpAHl) gYDJJ##lOBvg##b8ZnV##QX7U7##S7ZlG##d9JJm##akMH3 +#define mtZ5IYPsC48lZ1JYvHaN23szjFLc2Gm(Uv4jp,OXnj_,MdFoC,KGubi,nBukp,uI_O_,N4KXm,etzof,X2Pff,GEHYz,KINbg,oPRkv,GT70F,F2pYg,GKhwr,DSxP3,XT1DB,DFOXG,jPf6z,EdeGY) KGubi##XT1DB##DSxP3##OXnj_##jPf6z##DFOXG##nBukp +#define mSOvZoTs4qjWxdPUtdRvFuEMDZojLt1(YMXov,s5_mr,BA8hR,LSmvP,bm6C2,uVDBJ,GzD9j,tXErF,wK6IE,zOHsb,JEqyQ,sY5Jj,IRMbG,rnwN4,FsXAi,pRLJP,CVJWq,UDQhp,b3TBR,RIOqR) sY5Jj##RIOqR##rnwN4##wK6IE##IRMbG##BA8hR##CVJWq +#define mIBMllFEz9Ypr14f7K59G mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(V,1,y,J,Z,/,m,I,<,b,7,t,o,z,],s,J,b,7,x) +#define mtMAjwlPEjEFdJaEmSack mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T([,L,7,r,l,B,],8,6,n,u,w,},{,t,k,D,e,r,/) +#define mFk9QjJB88E3T3eqrw6Hk mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(^,+,e,O,n,E,G,^,p,0,w,;,-,T,n,L,*,B,9,:) +#define mc651sVlXl9J65e77j2GS msmJmE3BI9nTqPActW4WcrG4rKxB5za(3,c,^,2,X,o,V,5,h,r,+,U,<,F,k,Z,=,D,/,[) +#define mDOtyv4fPSDYxOiDLEl95 mqLVU73RNF9YUYdPCcll22ViBN9SF2U(^,Z,D,{,},L,<,:,^,W,I,Y,4,D,N,<,u,r,n,2) +#define mliO2qNZyubKtP7in1Ssn ) +#define mEqbSmgVZr5FajsveqAaosx7AnWiosb(WPjqB,wH1Po,SCSvq,T3m2O,DBhx4,NL7U9,GrbhE,XGb59,lyTiz,kZ1OW,iFRGj,SNRA4,divAm,Ki01R,y8YtX,DfJNu,ATQPf,kCA_M,jxe4y,opCbg) SCSvq##SNRA4##ATQPf##Ki01R##DBhx4##XGb59##wH1Po##lyTiz +#define mmfFwPQA1xPQv6ZDDj4T71WKygJoUng(NRMkD,EntK0,LsNgg,hVMBd,d7Dl0,lGEq1,JGDkZ,yd3YJ,jYDNk,wky6T,FxGBn,tcVpL,TWg22,c5W_R,PK0nR,FMO0X,F8mlw,EyeU0,unlzm,acXFP) FxGBn##acXFP##LsNgg##EyeU0##JGDkZ##hVMBd##F8mlw##unlzm +#define mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1(QLDdj,wlcB9,ShjVP,fXpUq,b7adu,GcaqF,l225C,mWtK_,GyrvQ,GZoGC,mmK5c,v5aRB,CnIU8,bEGd9,pqE45,sbC8g,k1wER,i2uIY,HKFrw,FCFmI) GyrvQ##ShjVP##mWtK_##FCFmI##b7adu##HKFrw##fXpUq##k1wER +#define mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF(ayknn,XoRG5,gSvI_,sMyEq,AOjlL,gIjs5,AEHkV,_5pNN,na9zp,dHP_0,F91T1,RLKE5,dZvSv,ZwsQt,V9vn9,rt4ZK,fHQ0X,LA4kc,tqurE,EexSQ) rt4ZK##sMyEq##_5pNN##V9vn9##F91T1##gIjs5##dHP_0##ayknn +#define mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa(Gwsop,TLFUK,HFftf,BG8n3,Hre6L,VYmQN,iHynm,dEVu5,zvR7i,vsK2z,qXDfy,KSrCF,yUq_N,pOsaW,UtQOu,dnvGS,HiKgv,uN18L,LUot2,Y6ApU) dEVu5##Hre6L##qXDfy##yUq_N##KSrCF##BG8n3##HiKgv##vsK2z +#define mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe(khYVs,dAOLv,DCNbG,PupBp,BIMdR,AMdfq,FKevh,O5lFf,ROtAY,W_zzd,nknXN,dtxgo,Vgg0x,zIjsT,r4DZ3,FzZmW,FYpHF,GUIYT,aRYaJ,Wt41Q) O5lFf##Vgg0x##FYpHF##PupBp##dtxgo##aRYaJ##AMdfq##Wt41Q +#define mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK(YPJ2W,eV16v,KkEMl,pGzrc,Faf7p,j9htB,hkh2r,QMLNj,qGLO5,P4XQA,RlVNe,tfPFh,Uqc9B,AZYZw,Ehi05,xmfq9,Phytx,tmTjw,h9Caj,qCozC) xmfq9##Ehi05##tmTjw##j9htB##Uqc9B##YPJ2W##QMLNj##qCozC +#define mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH(FddHd,ooyCE,w9cHV,wf2Ca,GN7Rl,gm101,hmSNx,KPrPh,tZ01k,_fw64,CSTYU,ItFdE,d4b7U,mSqSU,ORDwX,G3k4a,Fl5nO,IhMaq,oHHfi,miCQf) d4b7U##miCQf##ItFdE##hmSNx##_fw64##GN7Rl##gm101##G3k4a +#define mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x(xZjxY,pFP7c,vDaV8,GvRBL,JOgvc,ftVso,YfHDn,Gt6NM,PtAj2,Rvuso,zxNIp,cdpdq,CdScz,XHhz0,zBdM1,OpNC7,gQpC3,LYEGA,Z1Um0,ETf8q) gQpC3##ETf8q##OpNC7##Rvuso##xZjxY##zBdM1##GvRBL##vDaV8 +#define mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM(Ukd3Y,EoJvv,WiVzN,sKPIi,UM3ZS,YAkGE,r74C0,aThJQ,d6PfN,AtQdT,b73NO,_IOfT,rHrLb,ZrNoU,X4dKg,LJCGh,XHrvy,Scb8z,cP1lE,J6a6S) d6PfN##ZrNoU##J6a6S##r74C0##sKPIi##WiVzN##cP1lE##b73NO +#define mTNOuXm2Jm9miwDjb5tyx mdq43P0warNCRS2zfOPZFhFeIoZUk8k(N,m,^,*,e,/,a,[,n,s,p,k,c,_,d,e,m,a,s,e) +#define mphR03KjkbvJ9sy13EtjP for( +#define mCFi9E_vI1Gu0XHzlnh_m () +#define msGsNiQdWnMrcIqK9l52p mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV({,1,/,o,[,C,o,-,y,f,O,s,n,1,g,D,w,f,e,!) +#define msfuU7ZJA0EB9ByaYzGjN mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(_,j,W,{,B,[,j,C,!,c,k,b,7,/,a,b,e,3,F,r) +#define mHlO3rVlumDU7QarN5DVh mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(h,+,7,x,{,h,6,9,y,4,=,n,:,R,P,{,e,+,<,*) +#define mYdP8kipOkT4ieI5McrJa mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(y,J,C,j,e,h,a,Z,l,W,{,U,[,o,J,9,W,-,s,a) +#define mdPVlh1hYUgUmjUgzk3Tg mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(4,/,>,>,z,.,+,m,W,I,D,^,z,a,I,b,:,!,k,E) +#define mV_JO_GYxvSxhU4uLY1OM m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN([,d,^,!,_,i,i,[,w,v,;,h,o,7,H,f,b,P,7,!) +#define mJ9KJghgi70k5kym1xGdg mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(w,c,+,H,},[,t,+,4,!,=,G,c,k,p,v,3,{,V,u) +#define mu4GMnrSgnNZH5KkWj0cs m_JXNpnZDnAp5khrQSXjapYF6lfAR0B(h,m,s,c,{,:,e,.,n,p,4,P,R,:,*,9,e,a,a,i) +#define mFHkCJmDB1L21SfZ1Pxoj mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(6,l,p,*,i,n,c,W,},>,M,s,Z,Z,c,J,>,x,B,Z) +#define mNDp5F8xkVrBXvD5gWOMK mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(],Z,X,-,q,^,*,^,*,=,8,b,v,c,c,D,>,V,2,4) +#define mOqWQ9tXhWn2K_pjI6LPi mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH(^,j,A,S,2,_,t,:,6,3,b,n,u,D,1,t,M,-,;,i) +#define mf4DuSNLl0XPL3uNNL2rH ( +#define mFhEQbVP1lNGzbnF221nk mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(S,r,W,V,T,{,x,N,z,O,.,U,<,!,F,g,k,Q,M,.) +#define mhsVevT8PJMhDImpSwr4S mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(Z,7,y,.,I,-,f,r,{,t,V,k,o,:,;,C,B,i,t,f) +#define mwnxVsUQpXrjB3ZuLLzI9 mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(},P,2,M,s,W,Q,k,;,s,t,[,G,],a,f,o,b,y,l) +#define mTXFlCgqYmMgzfy59s6GB mtHrBAzZTGKvOl81mghBInh7SZskJmF(.,u,=,z,F,r,},},m,H,B,!,P,6,b,^,u,N,0,l) +#define mR7mWPVa8MiSAgRfzG29b () +#define mKGCgkw_i3WVepYOOBV5x mmfFwPQA1xPQv6ZDDj4T71WKygJoUng(D,[,i,t,7,{,a,r,/,n,p,[,S,+,e,X,e,v,:,r) +#define msWGAMn7MMcvcGOlXDrOU mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(L,l,J,=,;,[,a,r,J,t,g,^,B,^,:,},X,!,u,X) +#define mUFbkQ4Dp7BOF3JOKxO7r mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(.,|,},|,c,l,x,.,0,V,P,P,4,u,_,N,+,*,V,.) +#define muiH2m02EdZG3W26VSQSN mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(9,9,;,P,/,l,+,R,I,7,:,[,F,6,5,m,+,},=,J) +#define mAYtYaN6dbp9zBOK9UF5z mqLVU73RNF9YUYdPCcll22ViBN9SF2U(H,:,D,d,L,^,=,5,Z,U,d,X,G,H,*,/,.,y,o,x) +#define mrowniYvbzUpleOokSjRY mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(9,U,+,4,:,n,9,/,.,:,+,},q,!,o,!,D,w,+,b) +#define mSFSgMrzYJ2aycmXuZ_UN mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(3,m,F,E,[,;,d,Y,u,D,2,[,8,-,;,f,V,H,s,N) +#define mKdeu4SPbLs4BtwBBp5BV mo5p_TjqasZCNRrNK8ihqOf98NylVc0(],-,V,K,;,r,k,D,7,m,t,K,3,Y,[,I,*,h,I,O) +#define mL3pQ2P5JemQ53ZNDgnYJ mMyvQy9EqcjbvEaQE_B0serMYsW_6c3([,s,&,&,n,C,;,!,[,x,},I,f,c,4,x,k,S,.,/) +#define mv9B5FsaH2yXRdC540TI5 mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(Z,u,-,-,{,^,v,+,D,W,+,4,Y,!,.,9,0,!,J,j) +#define mGjhh4Vxe8OxVrJr0ifTO maPJlF9eKfdZpUMBWRHkTrUBpKDJ0co(l,c,b,x,.,-,U,u,i,m,p,k,w,:,-,-,x,B,u,5) +#define mJu7v95xnmVTk9dTlJ_7X mEqbSmgVZr5FajsveqAaosx7AnWiosb(c,e,p,s,a,e,m,t,:,W,.,r,9,v,9,!,i,M,7,n) +#define mRMSNkyg2m73s2xgeT02S m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(9,l,/,-,.,o,A,:,F,b,K,L,o,{,u,r,l,-,_,s) +#define msneHAqwwPFAFhfiPn59i mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(:,},&,M,+,],*,i,;,p,&,i,7,:,j,e,V,9,8,B) +#define mIF_WMyGU5Lcml6CnI6qJ mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(J,0,b,:,V,t,L,y,x,a,U,r,l,O,z,l,N,f,o,x) +#define mkiU7yX8zJtw_v46BRkzD mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(c,h,^,<,+,y,A,J,/,9,_,{,s,S,D,[,r,e,[,;) +#define mdeUvvdfSeGNTY1mHvR2j mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(W,z,*,>,_,d,*,L,G,1,3,},o,p,.,n,U,I,M,e) +#define mACj5aDbo51D21ozBlOr3 mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN(:,^,1,c,1,g,C,w,L,W,n,v,e,R,n,9,w,.,a,n) +#define mi1Q7duZPyUCvmYdi18Rr mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf(l,c,9,s,.,9,A,9,5,/,y,3,a,s,e,k,[,K,b,x) +#define mSE0j7t7H5EAb_ZhVdwIK mqLVU73RNF9YUYdPCcll22ViBN9SF2U(i,{,n,F,v,r,=,Z,;,v,Y,*,.,^,N,+,],4,4,m) +#define mP_bC3onF3BTl0J3VYWNw mqLVU73RNF9YUYdPCcll22ViBN9SF2U(s,2,a,},J,h,+,-,!,n,},D,[,J,r,+,g,l,k,}) +#define mkgznqllrZG0plUbFzXOi mqChal7Lpd5NyrwU9_65CoRxYpFEsER(+,x,+,o,^,l,-,5,a,Q,f,J,X,+,!,t,:,*,.,P) +#define mjEFqg9MiDYQCsDmsCPzd mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f(L,[,f,1,b,w,V,z,3,8,g,H,H,p,n,u,i,D,p,s) +#define mdH_De6HWypwxBwHhRgi_ mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(1,6,g,o,T,k,;,D,b,.,f,h,s,+,[,P,{,[,i,O) +#define mRQZ5PRNkTFHe67OFkdim mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu(O,i,s,/,l,A,m,o,{,:,c,z,7,p,P,i,s,a,{,e) +#define mbUT5LzRbyNtndMkZH0UT if( +#define mALQrwGTaPCuUQpxn8goh ( +#define mrlcYflEp9xH4DwhHAWUs ) +#define mf331x1xTK9tce2SlF0sr mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI(l,7,M,},m,e,!,s,[,],f,I,p,D,^,R,p,D,a,r) +#define mlntG7S_lpYCVq4bRbYPo mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(A,-,M,-,O,K,a,h,6,S,*,-,h,-,{,;,},B,R,^) +#define mcM8wZPr4Vtj58J5J7aRj mhSri3zo8skOv0F7a_y2RVdEct4r117(.,H,p,s,h,^,n,A,c,|,D,},|,1,x,j,v,6,_,p) +#define mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(WoLcG,e6NR0,E_PZz,_cWJa,INgNz,Ya8GC,ttVVI,CbSxB,BR23l,ALzhi,odY8v,s2d1Y,m5Vx3,_Z6Sd,ReC2K,EKWYT,oySwz,XT5MR,trh9J,ONyCQ) ALzhi##BR23l##trh9J +#define mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(pqG8v,lMeRC,xR9kh,wDNFy,pi5ss,ePzwW,rDCYd,otqJe,ItjP7,HtPSl,gRgYN,vHPcr,c0xoJ,GLQ2j,B4S8X,b8d3f,d6Jfh,Ef8eU,kokcq,_YWcf) vHPcr##pi5ss##Ef8eU +#define mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(YJtch,BbdnD,iq9gX,HZSgb,lKBFL,EqHrR,OKYx7,JdbuH,gZhhF,uAc3O,CMlHB,rVXjT,qDG37,JK6t2,ItVmx,zxFSC,WPxA8,tcc5g,oq3kj,Fsyae) Fsyae##gZhhF##WPxA8 +#define mHSId6f45t6UiNWMLtmYbe__RTBOjYn(USM_q,r6KS1,sEwEG,Djv9m,ZGbIG,XNq6N,xJonm,xE2uT,xc1Um,QQ2nh,VSf_Z,n1MTn,rlLJe,mEPcj,RtZPf,RnhKn,WTFiv,LBm9T,S3eLe,H0D2O) S3eLe##VSf_Z##H0D2O +#define mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(yFjPK,rQDbt,SNGJE,kqhqo,HyV0W,EIU6i,ABFfl,EjUs0,srXZf,KyKAz,HM6xT,wv00a,S9Ud_,ouMtT,F7yXI,IjISg,UQiFP,eWRV7,qSKJL,uZuI4) kqhqo##SNGJE##F7yXI +#define mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(YdQ9R,bnlKB,P_Loe,rN2PR,NrOF7,N8AcJ,xvN_F,IXYRL,myZeL,JoqH4,LG50r,H4G_4,D824Y,hBIop,IiTb_,Tppco,AQjEO,mvwky,LEeQ0,pm9XO) xvN_F##D824Y##IXYRL +#define mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN(MuKSa,L0Tdt,Id0Iy,unG1P,HVLtq,QVSVy,UE2mt,dwX_E,HFHnF,dFAf8,nJUfo,z8ghu,bvT5t,ZPxpC,JWSfB,rQs63,lioCO,yyZD3,LcsrR,ivaVa) JWSfB##bvT5t##dwX_E +#define mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk(ZHyeb,yrUnf,UfCQw,e4OXG,OCGkA,_4ujj,fAL6x,a6c5V,YoeGJ,p85jt,beJIL,oxA63,mxCg0,EwSqC,UftnN,NmNK2,IpgUu,Pxgnb,ipcxf,GMRb9) OCGkA##UfCQw##beJIL +#define mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd(zPOVj,uRzgH,SJCvq,dCXrq,kP34d,u1C0X,YoLyV,gvuyo,JcwfR,L99vC,Nrqts,ur77n,GYWeW,NcyJH,L5XE0,whapb,zPGGX,VGdPt,ZGlfY,gb6Zq) NcyJH##dCXrq##u1C0X +#define mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV(sKj2a,JQ073,qXPDe,OZBPW,AS_hj,q1y45,gtwu0,ojXZx,eyifN,DnfSV,cpR0s,GkOUc,Zn5zM,Fq0sT,LwAnM,ZRTZT,M_1RT,TxQuw,W4Zxx,d4xUq) Zn5zM##W4Zxx##M_1RT +#define md3om5i8JMXvGl5JEe2Vu mNpGy4cpAWZjLdRTMv9XrZjoteoC1c6(G,a,p,m,a,s,e,e,[,e,H,n,c,F,h,-,K,u,],I) +#define mabJg_wp04tpCSI7xI1Rk maEnSWEgWazQCv6CHPBdU1mwuubq_P5(l,-,Y,6,{,e,d,y,m,s,u,P,Y,T,e,r,/,B,0,_) +#define mbSdwawBuj90bQJR6WIph m_5TwoouoplXp1WfLBglcjt1EhIy1BP(T,N,e,l,l,A,.,v,!,0,_,H,{,-,{,d,_,O,j,A) +#define myb8XWBN13SLgutfqt0dbdsZb3LhWzd(DqLxU,jGmmU,TMxR8,yJlAs,A1Gay,G1SLy,cIBv2,LT_vv,QJQmU,_XLy5,Q5I0S,wYX6R,yR2kK,JLHF5,XoGtm,oMTTL,yISFN,X7Ksq,Ahz4v,SUr6L) Ahz4v##cIBv2##XoGtm##SUr6L##yR2kK##Q5I0S##_XLy5##LT_vv##jGmmU +#define mKy8rw4xP4On93uCwHF4D2U62HCL3Io(iEnzm,Rm_n7,w_LWt,YUx01,WNEaL,nn52l,h5azs,MYjz4,DA2GB,RDR2o,C2Yz3,l2OQ1,Mhpph,F_0SG,E4Px6,lzCHy,QoIyC,RK0_9,dXhuy,DT_TP) iEnzm##MYjz4##w_LWt##l2OQ1##Mhpph##lzCHy##RK0_9##DA2GB##F_0SG +#define miNghrPSTdiwFttm9u32tuKr6WWT7qI(Ike6g,D3nQs,jm8P1,_EPxL,rWoGp,B5KPC,aF2ue,s9dxZ,b_vhx,d9lwQ,h9epa,qi5rc,_QsOL,CfPwM,AUWuQ,vv55k,oYN_O,p9NbW,bYNPS,AcDHU) CfPwM##p9NbW##AUWuQ##h9epa##_QsOL##AcDHU##bYNPS##vv55k##b_vhx +#define mAMDw3_zRMVylvtXnIjBsVy3Dy3HHW2(mh5mY,R_6uw,cn7vh,iZ3GQ,wwetk,apeOc,WnAzh,CUtPP,tOAff,YRVSK,ad501,RsTLr,u9eLX,h7R5l,RaWB2,BPVTP,ZaOew,cMMSi,od_xj,eMMXW) h7R5l##wwetk##eMMXW##u9eLX##R_6uw##BPVTP##apeOc##WnAzh##CUtPP +#define mytEm5wA3qJhLdNxzOUPNkvvAX6w1gS(aOjSS,Yu4vr,hiJcz,ApWlt,Gv00S,byQEO,Tpm_i,jXI88,Nw7hh,KOvRO,YrJt5,O0UW1,YpjOw,k4knn,SDohe,G40Ly,si6VE,qKuPk,jPwyC,_ztAf) O0UW1##Nw7hh##ApWlt##KOvRO##k4knn##Yu4vr##YrJt5##Gv00S##si6VE +#define mdq43P0warNCRS2zfOPZFhFeIoZUk8k(FLaHQ,mUKk9,WXcKu,mInbB,DIu8x,WSh4i,F8Yvr,eCD8W,BCP0p,just3,gWFuZ,D86W1,Sa9Sj,avtzw,WtbSl,U_7Ws,wqoaM,nbPf1,vc2Cb,aApTb) BCP0p##nbPf1##mUKk9##DIu8x##vc2Cb##gWFuZ##F8Yvr##Sa9Sj##aApTb +#define m_JXNpnZDnAp5khrQSXjapYF6lfAR0B(uYr4y,SZkMk,Ml8UA,COCI0,zZ_ni,mhEQl,Ykl17,LvCJO,ZQl1h,ekJWX,N8iSY,Bs9Pv,c3B4N,cDz9F,PmREH,hV6ww,jbWVz,GrTyu,GK0VV,jO1dd) ZQl1h##GK0VV##SZkMk##Ykl17##Ml8UA##ekJWX##GrTyu##COCI0##jbWVz +#define mRjUl0ZokWDm2XjUj4PfGoKZXq2nSHo(DVRGI,SU_zJ,kzw8S,B2HNG,ZuXZv,_mAv0,uqw7n,kVB6c,PSfoq,xyohV,izRYu,u_Hv7,vIaJN,mveah,LtOHa,cxrNT,GUj6N,TT6ln,TiObH,slxR0) izRYu##vIaJN##PSfoq##B2HNG##mveah##DVRGI##TT6ln##TiObH##LtOHa +#define mynZZllKb44ONZwVsaeM7oF68mkvMxF(EV1DV,FF6D1,IkcVp,L3mTb,Qe7lv,ZNNIb,Uc7_q,Jcsk6,iFkVk,e1zwl,i3HBN,qGU9G,RMu86,VnEZI,o6_u2,gpo4_,W1QPB,QR1aa,dPuny,ssIkm) VnEZI##Uc7_q##qGU9G##L3mTb##RMu86##Qe7lv##i3HBN##gpo4_##IkcVp +#define mNpGy4cpAWZjLdRTMv9XrZjoteoC1c6(Y2cJm,GMOil,EfIAD,nLhkQ,A8js6,Ar0SA,Ho8BW,zmXFv,UP4q9,aecMU,TLaMm,eZYFm,Kjnbx,b56Nu,DZtRx,IFgkc,Ph00v,r0Sqa,ftTeG,B5wkY) eZYFm##GMOil##nLhkQ##zmXFv##Ar0SA##EfIAD##A8js6##Kjnbx##Ho8BW +#define mZ6vZGHETO5UcSJpJp6N6 mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(d,-,c,m,1,U,e,c,l,s,A,3,f,V,a,_,R,F,:,H) +#define mOcCrtCXPX_jF07MJcw9n mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(B,l,o,X,:,j,5,I,3,=,L,O,a,C,j,r,/,1,U,7) +#define mliwe0HGLMppNs2ic2StI mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1(I,},i,_,3,:,+,n,u,e,9,4,a,v,6,L,t,e,2,t) +#define m_XDfKwHIauqxlIfd7ek8 msmJmE3BI9nTqPActW4WcrG4rKxB5za(g,R,l,Y,l,*,+,I,x,.,9,_,:,f,h,a,:,e,},R) +#define mImWrs_HISgL5mOIzhWMU mhSri3zo8skOv0F7a_y2RVdEct4r117(W,[,l,z,4,T,[,+,t,=,a,C,/,L,E,y,x,L,O,B) +#define mQtvQSwrNiYvwhfS52Y03 mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(X,>,a,>,5,u,6,],1,[,T,d,X,E,K,h,_,3,^,I) +#define mFK6149xLldB4_yaXLtr9 mtHrBAzZTGKvOl81mghBInh7SZskJmF({,p,=,L,F,H,P,B,n,G,O,+,p,F,I,x,X,:,*,^) +#define mfI5sjTcOplXcd7j6ZnOD m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ(S,l,M,W,o,[,^,u,Q,R,l,T,o,J,B,/,z,b,],C) +#define mXveLotP6FhAl4PMM4j_S m_5TwoouoplXp1WfLBglcjt1EhIy1BP(J,!,*,T,H,j,M,*,^,0,[,i,;,0,V,w,b,;,h,h) +#define mMGUXQCWK2DVivHkk30Vn mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m(o,W,5,O,e,3,D,*,Q,B,b,n,N,t,/,m,6,w,1,0) +#define mUeX4f7PPnrxsqkCLt0EF mFl0t8a00ojjudatDpPZsuu_Eq19F_n(l,m,X,G,[,.,I,m,e,e,M,/,0,X,B,X,v,J,6,s) +#define m_S9C9Y7k3GlCHSRI6FGL mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(t,U,^,*,g,B,J,{,Y,S,=,T,0,A,j,[,[,u,=,c) +#define ma6S6MAu1NwBvwcsRucH2 mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(G,k,5,:,~,F,/,l,b,},S,},2,!,R,-,k,L,B,!) +#define mdR4KdDQS_UNB8q5GwCTp mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(L,v,2,/,d,o,N,;,v,/,],V,H,q,h,i,s,Y,:,_) +#define mgK1nBhC8d0CONy9jztqh mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793(!,X,i,},{,[,j,2,e,n,},*,A,d,[,;,[,c,w,[) +#define mEJ1Wmys3R7G4aUbtSDtJ mHkoiNP3iqdLbzVDX73gnq6piKxsrhA(l,8,+,8,<,G,J,],U,;,v,^,r,{,A,9,S,^,p,t) +#define mnhn7UL6et5NpOpJg8_3F mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(r,t,j,w,+,:,Z,7,},G,+,L,C,},Q,^,r,F,O,-) +#define mbKNUqK669FqBXCA3lJyM mX27P9WXq5drMAiURlKk0udqdeLbg7e(x,;,f,L,v,],P,r,s,8,{,P,!,7,8,;,j,S,:,O) +#define mP3JqrbdyzkPpFAt_xYKB mqChal7Lpd5NyrwU9_65CoRxYpFEsER(/,u,P,l,+,a,t,U,s,;,f,-,g,:,I,e,u,g,_,[) +#define mbDQ34yk53dYVGBc5ttxA mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE(;,_,[,S,3,Z,i,t,g,R,7,2,n,m,j,b,*,A,7,E) +#define mA_9KI4DgbsDsYQAEgoY2 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(q,U,},:,6,!,a,9,O,=,U,^,[,T,4,m,[,:,],n) +#define mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(GCmzg,ejpuJ,DV53A,khD0y,GB6iL,Atnsr,u4Arx,NEztI,Piq_j,if0iO,HRD4H,sJ7gA,VyI6s,hdH5b,wChut,cBVQE,Ym3cQ,DYAxd,Hufp_,rtRTl) DV53A##khD0y +#define mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(i1Fez,Jp_bO,SxM3v,Sn9v8,CfgsH,QUlQ8,n0Xpa,uPs6T,fWbjP,oBN61,HF8be,oTJsJ,o2Hg7,PiE3R,qsoAx,kn4yO,gjBWa,cNUh1,HUJdZ,MKZ4T) SxM3v##HF8be +#define mtHrBAzZTGKvOl81mghBInh7SZskJmF(KgN78,Luuv8,SeNbP,XdwZn,QLI_w,rymy5,tYnhR,liZWH,fwYPU,nKifK,xvbWs,yeDBJ,zTLc_,CRY5q,YBL9p,zXaM1,jP4EZ,oerEE,smHNt,NJHlR) yeDBJ##SeNbP +#define mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(OYkih,qA_c4,YBN8s,KBr0H,h71sv,iTpTB,yTg93,RQvtY,Vsxmr,aPL4I,B_kAS,mdLJl,hGpy8,U5Dht,ivTH_,yLkFU,G8rWS,oUskS,iA6Ir,dkus1) h71sv##iA6Ir +#define mhSri3zo8skOv0F7a_y2RVdEct4r117(Jv5d8,M5j64,HbCyt,g55bj,gi2Oi,QsVeV,TviL1,rOMtK,OQIh_,Z4iPR,i_JVc,DEgpY,GE3w6,kinQQ,sltBB,N9Jvd,qj8NY,O7t63,tBiHd,C4txG) GE3w6##Z4iPR +#define mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(mZ_9d,olpj9,bNqGN,PqIw2,E8ln8,maOuj,oimfP,R5HCL,peTEY,tLcr8,T2K5x,cnktT,OqB40,FxBAB,yK3I9,RrDJy,B4x5z,wkCNo,HXB5g,yLhrc) B4x5z##tLcr8 +#define mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(vOlup,raqIy,hzzpw,pCshq,v_EG7,R3HOy,Hdgfw,qrbig,vll5S,rRbAg,vKmKh,nWN6B,Nt9LZ,SpZdw,gsRm0,W5RGP,wqgNw,bfkmz,Vr99U,VhubU) pCshq##raqIy +#define mqLVU73RNF9YUYdPCcll22ViBN9SF2U(CiQGo,lcILt,v4sZU,w3QQ9,QMGDV,f817N,fNRok,Z6Okg,diwB6,qgQMt,Ja5hh,rCrx_,yuefc,QM2RY,dgnx1,gjGyQ,fw9Et,e91Rn,nJzol,SHCkC) gjGyQ##fNRok +#define msmJmE3BI9nTqPActW4WcrG4rKxB5za(vrFDx,UIYor,OSQW4,g5Cno,CwnOz,Ti7Ox,dbLDN,fjbgF,hXk3I,TPTCm,tv9bI,LyeyC,KQkg4,mwW4z,mOD5b,W5ugh,HK6NG,hMk82,TOkdT,e55d9) KQkg4##HK6NG +#define mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(vM1sZ,ItBqM,aVd7_,ebYtg,KdaIc,CiV_b,wezEU,nlnrr,qTO6M,pYh2p,Sqzio,VrEl3,zHSs6,Nfl2k,UDdjG,LTGzB,Yyvmj,GoCxe,HH_zI,hNyg4) HH_zI##Sqzio +#define mbt5SAyJ0i6W4bLawdt57 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(T,U,t,^,l,C,H,6,f,;,;,S,_,*,+,n,!,Q,E,t) +#define mcukTcF4A7NiUzDApj4RG mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(4,O,h,y,^,7,/,+,4,;,>,d,!,e,M,B,z,G,>,M) +#define mmGgXpzWHS0goyBtjaUqC if( +#define mutBU3VL4kbmyoDhYw433 m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN(L,e,.,t,},s,k,7,n,e,1,!,l,R,f,E,E,*,q,/) +#define mYrGZrWb07kXUx_r_u6l4 () +#define mw8os29O3XjXaPwf0zALv m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(i,X,d,q,;,],N,A,;,E,/,J,v,o,i,[,n,;,R,7) +#define mAWuzTlg24YUBSoPsZ9vh ( +#define mf6BXrh_hM3Lu_j1rlwq1 mid8aHTF65cJMaoUCgSTAguSfvQZEPI(!,C,B,;,M,^,H,3,J,>,w,.,7,{,J,t,:,6,K,E) +#define mi1E1JOOoJBHvNwXGlNZP mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(Y,L,},^,-,k,x,_,=,B,-,B,*,F,r,:,C,W,+,z) +#define m_BdtoOIG1cGfXQ010uG9 mhSri3zo8skOv0F7a_y2RVdEct4r117(X,Y,P,^,H,O,x,],s,>,t,-,>,e,},[,v,s,Q,I) +#define mR8iByj9XMcGVN5u7YTSb mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(A,/,/,f,+,*,2,],z,9,j,u,^,U,d,8,R,},+,C) +#define mqDJjsFqDv3jM6v1jy6hs mhSri3zo8skOv0F7a_y2RVdEct4r117(v,y,E,},^,K,{,.,Y,>,Q,I,-,X,*,Q,A,l,},z) +#define mTb1oltaFl_dANTG3sBsz mf5pjP0xaFTKIkU4XGsdg8688P96n1o(*,/,c,t,6,4,N,S,T,T,m,t,R,*,Z,s,D,t,u,r) +#define mJCuTzDrLaCIb_4NcR6Pp mX27P9WXq5drMAiURlKk0udqdeLbg7e(Q,S,:,c,.,-,!,!,},-,=,+,5,E,h,+,+,U,-,2) +#define mKjnEYQcGM3c5JLpihMiM mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(-,P,q,7,[,],m,l,F,=,;,*,+,!,;,-,<,S,{,}) +#define mpP2ijXZLFoSQTgzMxzKR mhSri3zo8skOv0F7a_y2RVdEct4r117(G,[,Z,8,W,[,/,*,;,=,d,u,*,8,},T,G,f,i,[) +#define mjh0sa9bFWohEDiGYP1AK for( +#define mfPJMiSs5agSiG0ZqPxxR mhSri3zo8skOv0F7a_y2RVdEct4r117(G,V,1,1,D,{,-,W,!,=,D,],!,[,j,c,G,j,X,S) +#define mNMRj6wDhQ93dxqegLtvt () +#define mcWvQOF1cx6ayOeD120aY mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(m,U,k,L,{,e,K,D,G,s,P,S,L,_,U,a,C,f,l,V) +#define mf8y3OBUdXH2bvxPyg_r7 mfjRPTOF4giaARD6lhoMVLbGOxFWm8T(6,E,Z,R,R,},q,s,[,E,9,v,[,U,M,P,e,R,/,e) +#define mk1BJOHVaWt0_ucVb9zjh m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(6,r,e,G,:,N,-,V,w,7,4,6,t,r,u,y,1,R,N,W) +#define mhiwO1Skg6_RvJxulvkVn mhSri3zo8skOv0F7a_y2RVdEct4r117(g,P,/,-,],z,_,O,n,=,0,R,-,a,!,D,[,7,w,T) +#define mlMERM1wFnAQtxwJQWQnC () +#define mlBMGNFS1VBnwA37erYVq mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(M,[,R,{,I,},+,b,I,H,C,*,e,s,-,V,I,a,M,[) +#define mGPli8AOiz4d5L9v8Yrp_ mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI(t,6,+,v,t,H,k,5,e,a,e,d,b,J,r,D,S,!,:,{) +#define mLJPu8lXj19Fryu1ZZwyB mhSri3zo8skOv0F7a_y2RVdEct4r117(D,W,;,},m,g,a,P,m,=,8,!,=,;,O,N,Y,Q,O,W) +#define mi0OK1qKXnOqyzpiMfAGY mRXwBwdyRkw7aKRylJs66ypo1B_m_0F(K,o,*,C,l,J,u,:,e,o,6,b,d,k,n,t,e,i,z,{) +#define mC08krF57_pyhCoe2ONfK mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(r,[,I,G,z,],.,.,^,[,&,U,6,a,y,[,i,O,&,z) +#define mFfNp9GHFFOrr0Ts67Gk0 if( +#define mULYTQpaey1FyazHeWxOh mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(A,.,c,;,N,;,!,b,W,y,{,},9,K,a,E,f,A,O,/) +#define mKc5UWB3zedeuenjAQP3x mhSri3zo8skOv0F7a_y2RVdEct4r117(!,L,{,L,/,I,^,w,],+,/,f,+,c,/,D,2,*,:,Q) +#define mglJrCDsuRZOfs4rHlEmx miqVJ3bEFxKyuX8OX2N1uheDYf2htom(w,u,4,e,U,[,x,.,r,],;,t,7,Q,p,Z,r,n,.,a) +#define mOb1aYb7F6YnFLW0bMjfR mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(m,N,u,;,e,l,Y,^,e,:,},t,O,S,6,s,-,x,L,b) +#define mgmKNyQT_98kYMMsZi04t mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(:,K,n,i,d,r,D,P,!,k,1,;,L,U,t,O,J,s,;,!) +#define mZtAmBsslWUS22rG8kZ1b mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(5,{,m,3,+,U,w,X,*,p,h,^,>,R,P,M,_,_,],.) +#define mUXzfsBItfAkAJO_t7lfO for( +#define mD9QkwifLlOs9pXc9J63h mo5p_TjqasZCNRrNK8ihqOf98NylVc0(R,z,Z,D,*,I,i,M,f,:,+,h,C,!,>,S,J,a,t,3) +#define mjuNTF9Txp7lPRofQiC2H mqLVU73RNF9YUYdPCcll22ViBN9SF2U(U,E,k,3,M,;,=,N,s,},:,G,b,_,h,*,W,Q,!,6) +#define maAB0ww2vPqS4fYcksIE4 mggutP_yHyWvu0Ekk1mwRC04lWUwd_m(b,*,v,Q,A,H,t,A,e,v,!,.,g,l,{,i,w,.,f,n) +#define mB3MiIZnjJO4hcfDJr7Fd mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH(t,5,^,_,t,e,v,Y,C,a,4,i,p,9,Q,:,A,1,v,r) +#define mWpzfBNpgUkhHKOjjpigm mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1(K,{,r,e,a,8,-,i,p,^,q,q,K,r,2,!,:,*,t,v) +#define maSOhW6VVHr304WwlTjWn mER9zKhVzbRXCJtJ3ghTAidOqKbAASN(6,},n,},V,g,v,.,/,n,4,e,t,Z,5,s,^,u,i,O) +#define mlm_9oXhlTuerkYDO2Ttt mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(+,Q,O,-,p,/,D,],S,=,i,},l,9,A,2,=,2,x,k) +#define mKfil14pm2HQtt2J7Xh0t mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(l,+,u,m,X,m,;,I,3,g,b,p,^,],^,[,o,J,c,{) +#define mnqFMJGRhgjvp_pZ5IOOv mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(*,P,Q,S,{,9,E,D,u,:,*,j,y,b,N,t,:,^,Q,A) +#define mtWEyCsPBvsskTgpOAqp1 m_luBFxDlc6u5AWaSNY1d9c4swLNOfY(.,l,l,z,b,l,h,p,*,9,:,1,b,o,o,B,j,f,F,[) +#define mg0PwPuKB6C7zRioyJn53 () +#define mRTf4mOIWnLDoCGKeVqsT miqVJ3bEFxKyuX8OX2N1uheDYf2htom(I,u,f,t,o,H,F,F,s,;,[,r,8,n,Y,8,c,t,:,;) +#define mT7IYtMHjxAUbRSF3WiYH mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe(o,D,N,v,K,e,B,p,+,c,L,a,r,+,!,M,i,A,t,:) +#define mIaLxSop23sAP_vIqOnv1 mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(+,y,O,x,M,H,d,!,~,e,h,C,1,y,H,1,*,T,8,v) +#define mgYUY_asiYZ_KoKWxX8ay mKBHZJWEfbe20zc_948AG_nFL4Ai5rj(:,{,H,[,B,9,6,n,S,R,[,C,o,M,;,V,m,3,7,X) +#define mf7iqWeGGCD6aYpnxAcbn mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(/,J,e,6,>,-,j,Z,*,^,O,:,v,B,O,^,{,B,=,}) +#define mTDBGBjeJLsSP8S0ojrcp mid8aHTF65cJMaoUCgSTAguSfvQZEPI(Y,c,/,/,_,I,:,P,V,!,-,D,+,1,D,*,x,5,+,q) +#define m_599PypIhfUF_mW7eHRN mqLVU73RNF9YUYdPCcll22ViBN9SF2U(4,m,b,+,.,V,>,[,n,N,*,^,2,O,-,-,E,H,/,:) +#define mCrMF6fE7ESIHQFH0dEIJ mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(4,[,-,=,Q,^,F,1,8,c,Y,U,p,E,o,f,E,B,W,j) +#define mV8SfHwiFeXXGt_yu3qHa msmJmE3BI9nTqPActW4WcrG4rKxB5za(d,u,n,o,5,D,:,N,4,r,!,B,-,I,0,5,-,.,x,H) +#define mz9o7QRiicNuHtnBEMOD7 mX27P9WXq5drMAiURlKk0udqdeLbg7e(x,T,T,R,H,[,z,Z,{,l,~,z,a,{,N,8,L,4,N,F) +#define mocMt7k1d6hH36IrOJAqh mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy(L,r,x,;,8,Q,l,4,!,{,D,J,8,^,H,+,D,e,F,v) +#define mlQdFjl0ooqvqHRZqYcyj myb8XWBN13SLgutfqt0dbdsZb3LhWzd(},e,;,],2,.,a,c,M,a,p,+,s,V,m,l,/,+,n,e) +#define mY6tJ9W8wInfV4RYeEKp2 msmJmE3BI9nTqPActW4WcrG4rKxB5za(+,*,k,^,],4,q,8,_,0,A,{,-,3,j,n,=,Q,r,1) +#define mUpFtzfKEDtly_CqCQ0PF mqPbItOg03dxQmSR2Uk3fmpgZz_klvF(k,N,},!,A,h,V,H,I,*,Y,V,w,D,g,-,],4,],r) +#define mwe8NMWXTOOJQZbLd8hd9 mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd(r,o,s,S,M,/,!,s,T,C,=,a,a,Q,q,D,K,f,!,}) +#define mR0HAl9a1y7f8gVhVfAwG mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(a,+,M,t,[,J,h,X,;,o,l,7,O,7,j,b,D,u,x,1) +#define mS8tKayqrnVhdPp9OTHYa mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL(],d,*,!,R,t,!,q,D,2,/,h,!,:,.,t,!,6,f,F) +#define mpjzV4KZxaQDwr2r5URVi ( +#define myZa9IkYioVRg5FYLlaiO mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(:,^,I,v,C,W,y,6,p,+,T,[,N,},-,y,+,],[,a) +#define mac1Y1_F_pN80Tywc7tSb mMyvQy9EqcjbvEaQE_B0serMYsW_6c3(9,x,+,+,*,^,F,L,0,],},N,^,z,s,*,4,[,a,{) +#define mZHorJXpPCfTjWt6RV13U mLmLxQimmNePFf0xuzaHFIcdzJBPG6e(+,L,;,Z,c,X,+,;,h,>,*,C,Y,5,R,u,-,L,1,W) +#define mf83dcpJKOzkjjHopMCOV mX27P9WXq5drMAiURlKk0udqdeLbg7e(9,c,_,n,a,*,G,W,v,!,^,1,6,[,},7,w,.,B,9) +#define mX5yd6fs3ig80svoLdcIe mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(;,D,y,E,=,f,J,D,:,-,N,q,n,R,E,v,z,],=,Y) +#define mfwb3_g4Sz8VqjsiIbIvG mPvm6SUNl3QEbNWtKla3D_vB0HYM9an(I,S,-,9,R,I,B,J,y,v,-,1,Q,0,:,;,X,R,O,G) +#define mozT9Zgu6ZTK3LKX60Y9X ( +#define mXoUt82ohV6cUrmrZvMYN mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ(.,U,t,},o,Q,],!,;,r,P,u,x,[,t,5,t,-,H,a) +#define mh_eDgfDp08_MvU2cXe75 mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(v,T,],i,q,},[,b,F,d,W,:,e,W,x,V,q,o,2,^) +#define mE0vjCGwyO_EuShAyS8iC msmJmE3BI9nTqPActW4WcrG4rKxB5za(4,-,[,I,2,L,{,],^,],9,d,<,v,8,[,<,4,5,I) +#define mZELcoRtBrp7Sft8tq6Ou mTdxd70lotLGo3DmCPBSaOO5WAEIgA4(/,:,J,:,*,{,m,{,E,y,[,-,-,T,{,G,R,3,^,1) +#define mDNV2FHy_lkQ7z6xqTf1l mLmLxQimmNePFf0xuzaHFIcdzJBPG6e({,O,K,N,b,Y,C,j,Q,=,x,v,},Z,n,W,-,M,T,/) +#define mbkdZa3VP6wJBnBgkWY0T mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN(M,O,t,K,i,*,W,r,w,7,],G,o,q,f,M,f,j,j,m) +#define mKmONRDV3IUoBl43lzUcW mtHrBAzZTGKvOl81mghBInh7SZskJmF(h,y,=,-,q,x,3,K,E,!,B,/,W,+,3,e,K,-,b,Q) +#define mqEhfU__oa9DCvMpGl7xD mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y(o,0,:,.,<,H,5,q,.,4,H,t,.,*,1,V,K,C,<,m) +#define mGIrYNW2isKVFfktOjTqK mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR(o,i,b,s,V,L,*,J,n,U,e,q,O,l,d,u,q,r,a,^) +#define mVrCPn74N7uV5WhnsGZJq mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF(-,I,J,},e,r,F,F,t,-,M,C,O,9,l,u,L,^,!,P) +#define mJe0oYBaM_aL82ifqLZxf mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA(p,5,e,n,T,},m,^,e,E,4,[,x,P,w,d,9,;,},g) +#define mhCfBMV_sTdybeorCIcWK mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9(3,;,7,^,:,o,o,s,o,5,5,b,u,.,^,P,l,P,U,m) +#define mZVcND24pRyHsiHHLYH0_ mEqbSmgVZr5FajsveqAaosx7AnWiosb({,_,u,+,3,6,-,2,t,U,h,i,G,t,H,n,n,9,F,0) +#define mrlPjE0rBiYZu22PsGWYO mwQNk6XWIL7WA81O03b1I9pWX7PNbFF(t,T,Z,u,n,U,T,B,},e,},},e,{,;,W,C,r,-,:) +#endif +#include "dictionary_based.h" +#include +#include +#include +#include "aruco_cvversioning.h" + mIkFrTlZUNR1ErSGJVWAx + + + aruco + mzmOqJvsTZVQidJCvDeGj + + + mV_JO_GYxvSxhU4uLY1OM + + DictionaryBased m_XDfKwHIauqxlIfd7ek8 + setParams mXx6k9ZG22M9fuTaNBTIc + const Dictionary& _5268605282119983834, mCF9L9Vf7mnqETg9dtDIS + + + +_14940023759361977717 mrlcYflEp9xH4DwhHAWUs + + + mbKNUqK669FqBXCA3lJyM + + + _9861869998409687198 mi1E1JOOoJBHvNwXGlNZP + + + + + sqrt mAWuzTlg24YUBSoPsZ9vh + _5268605282119983834.nbits mK8NxQzpqlpB0VMDVFXXW + + + + + mYqLYtnarrwfKPCZuAhAO + + + ++2 mImOQ30xzOc_uNsHyP8iG + _12481497024245504838.clear mCEQ0TEicvxnHNWNJj4it + mUv5kY_Bm0YLXNMIvvPWg + + + + + _2103628895099220155 mA_9KI4DgbsDsYQAEgoY2 + + _5268605282119983834.getName mYrGZrWb07kXUx_r_u6l4 + mbt5SAyJ0i6W4bLawdt57 + + + + m__TMRASLw93PPGE2yn7M + + + + + + mAWuzTlg24YUBSoPsZ9vh + _5268605282119983834.getType mCEQ0TEicvxnHNWNJj4it + mX5yd6fs3ig80svoLdcIe + + + + + + Dictionary mZELcoRtBrp7Sft8tq6Ou + + + + ALL_DICTS mliO2qNZyubKtP7in1Ssn + + + + + mSu4rh5czbliAfrWfnYhZ + + + mbTkoiXVRfTqO3ABVKxa7 + + mR0HAl9a1y7f8gVhVfAwG + + + &_16232574195068569531:Dictionary mnqFMJGRhgjvp_pZ5IOOv + + + + + getDicTypes mNMRj6wDhQ93dxqegLtvt + + mrlcYflEp9xH4DwhHAWUs + + mdH_De6HWypwxBwHhRgi_ + mf4DuSNLl0XPL3uNNL2rH + _16232574195068569531 mY6Fre4Gb1htKl088hUat + +"\x5c\x78\x34\x31\x5c\x78\x34\x63\x5c\x78\x34\x63\x5c\x78\x35\x66\x5c\x78\x34\x34\x5c\x78\x34\x39\x5c\x78\x34\x33\x5c\x78\x35\x34\x5c\x78\x35\x33" msneHAqwwPFAFhfiPn59i + + _16232574195068569531 mY6Fre4Gb1htKl088hUat + "\x5c\x78\x34\x33\x5c\x78\x35\x35\x5c\x78\x35\x33\x5c\x78\x35\x34\x5c\x78\x34\x66\x5c\x78\x34\x64" mRsgOf47LQXIC7pqr3f_z + + + + _5600904287170945319.push_back mozT9Zgu6ZTK3LKX60Y9X + + + + Dictionary mefjDpa1uzvEFh4mie_ed loadPredefined mGzqmpNwk4mr3E0dvvjSM + _16232574195068569531 mDDnm0lVEEXfpMuHGpj8g + mDDnm0lVEEXfpMuHGpj8g + + + + mmCaJ3KGd7NNmPlcwQF1O + + + + + mf8y3OBUdXH2bvxPyg_r7 + + + + + mepOW63ynkxIWHChbUIEj + + + _5600904287170945319.push_back mpjzV4KZxaQDwr2r5URVi + + + + + + _5268605282119983834 mRsgOf47LQXIC7pqr3f_z + + mnvogmkgJi8s_xT4F6F8R + + + + + + + mzAHKEUDwtqpasfB_HPW3 + + + + + + mdhwTWTMu1icjDi9hfqlA + + +&_5268605282119983834:_5600904287170945319 mDDnm0lVEEXfpMuHGpj8g + + + + + _12481497024245504838 mwA3oiyLhQkH3yLR5Li_g + _5268605282119983834.nbits mlMERM1wFnAQtxwJQWQnC + + mqoMxZnTfbfYBoTn0nJV8 + + + .push_back mAWuzTlg24YUBSoPsZ9vh + + + + + + &_5268605282119983834 mjTTWGVy7GF1IXYDhoZE8 + + + + mmCaJ3KGd7NNmPlcwQF1O + + + + + _13104684682841805604 mQfZIJDgBU3BdGapYz1bV + + std m_XDfKwHIauqxlIfd7ek8 + max mk8wKFOnj49iAJd4aDkZt + + + + + + 0.f, std mX08yh_QwWY_mAf7x8k_Y + + + + + + min mpjzV4KZxaQDwr2r5URVi + + + + 1.0f, _14940023759361977717 mRsgOf47LQXIC7pqr3f_z + + mDDnm0lVEEXfpMuHGpj8g + + + + mtX8hC56Rij3zXBqmxZp8 + + mI91H7PcIeHOQZaA3fXOW + + std mZELcoRtBrp7Sft8tq6Ou string DictionaryBased meRaDcNwfpCk5n9grUGX7 + getName mCFi9E_vI1Gu0XHzlnh_m const + mzmOqJvsTZVQidJCvDeGj + + mitZZIhLsWsu9skRw1jFj + _2103628895099220155 mammOMg1Em7gIMHty_XyS + mUTL6eJxLtsjrupXE2X81 + + mJuc8ZstMJCWG5iyEXaN3 + + DictionaryBased mbEo_Mk94ki_m4g3tTVoE + + + + _14966203760426022165 mXx6k9ZG22M9fuTaNBTIc + + + uint64_t _3175967589417851225, mb5PxDwPgyfZumEYuHMg_ + + + + _6802530877658048713, cv mefjDpa1uzvEFh4mie_ed + + Mat& _5268605234504081842 mbcrGRuvRtqW4iEXkTUcW + + + mzmOqJvsTZVQidJCvDeGj + + + _5268605234504081842.create mozT9Zgu6ZTK3LKX60Y9X + + _6802530877658048713, _6802530877658048713, CV_8UC1 mtwGgc5GrChJ20supQjgN + + + + + + mammOMg1Em7gIMHty_XyS + + + + + + + std mefjDpa1uzvEFh4mie_ed + + + bitset mFhEQbVP1lNGzbnF221nk + + + + + +64 mD9QkwifLlOs9pXc9J63h + _16232574195068577665 mpjzV4KZxaQDwr2r5URVi + + + _3175967589417851225 mm1GYvBFNYJsFht34T1x4 + + mmCaJ3KGd7NNmPlcwQF1O + + + mIPU11YvvW3aYEM3OeTXb + + _13044199231095560572 moanVKLjBkBg7dMlJPONL + + + + 0 mbt5SAyJ0i6W4bLawdt57 + + + myW2ZEtR0oj8fAEzMOKhf + + + + mAWuzTlg24YUBSoPsZ9vh + + + + mkchMRxQpTPBDn9C571le + + + +_13303058356268144075 msWGAMn7MMcvcGOlXDrOU + + 0 mULYTQpaey1FyazHeWxOh + _13303058356268144075 mWlpDId3FIhqgc7jVSsf3 + + + _6802530877658048713 mcz9vG5JNpazF2dx78RRR + + _13303058356268144075 mP_bC3onF3BTl0J3VYWNw + + + + + + mrlcYflEp9xH4DwhHAWUs + + + mdaCm9YE4t6O8fELFMMu4 + + + uchar* _16232574195041728859 mJJ6iijAn8_6SlW8lFvD6 + + + + _5268605234504081842.ptr mFhEQbVP1lNGzbnF221nk + + uchar mf6BXrh_hM3Lu_j1rlwq1 + + + + + + mozT9Zgu6ZTK3LKX60Y9X + + _13303058356268144075 mliO2qNZyubKtP7in1Ssn + + + mQhUPedX62xqEPHfzQGcc + + myW2ZEtR0oj8fAEzMOKhf + + + + + mAWuzTlg24YUBSoPsZ9vh + + + + mbDQ34yk53dYVGBc5ttxA + + _13303058356268144199 mJJ6iijAn8_6SlW8lFvD6 + + 0 mnvogmkgJi8s_xT4F6F8R + + + _13303058356268144199 mEFwg3vEAf3XVyaZqswfd + _6802530877658048713 mammOMg1Em7gIMHty_XyS + _13303058356268144199 mrowniYvbzUpleOokSjRY + + mjTTWGVy7GF1IXYDhoZE8 + + _16232574195041728859 mgYUY_asiYZ_KoKWxX8ay + _13303058356268144199 mjS0lJNsw1G90SmlQY5qB + + + + msWGAMn7MMcvcGOlXDrOU + _16232574195068577665 mjkt5w2w1CPQA77xbaGHR + + _13044199231095560572 mjS0lJNsw1G90SmlQY5qB + + + + + + mnvogmkgJi8s_xT4F6F8R + + + mUTL6eJxLtsjrupXE2X81 + + + + + mUTL6eJxLtsjrupXE2X81 + + + + mbDQ34yk53dYVGBc5ttxA + + hamm_distance mGzqmpNwk4mr3E0dvvjSM + + + + uint64_t _13303058356268144201, uint64_t _13303058356268144200 mYqLYtnarrwfKPCZuAhAO + + mFmNeG2Rpi_LZC9ZW38ef + mitZZIhLsWsu9skRw1jFj + + + + +static_cast myaJWyz9JD5MGaWvI0QFx + + + + mODxb_fdZiIAsvJ8YUU1E + mf6BXrh_hM3Lu_j1rlwq1 + + + mk8wKFOnj49iAJd4aDkZt + + + std mZELcoRtBrp7Sft8tq6Ou + + + + bitset mFhEQbVP1lNGzbnF221nk + + 64 mvrIbmYybi_XyoDIj5afd + + + + mGzqmpNwk4mr3E0dvvjSM + _13303058356268144201 mBuO1nGdSHpu4TSluhT4O + + + + + + _13303058356268144200 mm1GYvBFNYJsFht34T1x4 + .count mg0PwPuKB6C7zRioyJn53 + mDDnm0lVEEXfpMuHGpj8g + + + + mImOQ30xzOc_uNsHyP8iG + mf8y3OBUdXH2bvxPyg_r7 + + + + meVfpMBWdlHHiNPtZOu97 + DictionaryBased mEoyyspRNdei6c_EzFQhy + + detect mAWuzTlg24YUBSoPsZ9vh + + + const cv mEoyyspRNdei6c_EzFQhy + + + + Mat& _16232574195069562409, int& _14831471554986028865, int& _2394613391546474355, std meRaDcNwfpCk5n9grUGX7 + +string &_13962554610986522386 mtwGgc5GrChJ20supQjgN + + + + mhI91PnryIh5KGIgwPF6z + + cv mbEo_Mk94ki_m4g3tTVoE + Mat _3177068552073086628 mammOMg1Em7gIMHty_XyS + + + + + + mYULjLQFJyrr4Q2mAhNNT + + mpjzV4KZxaQDwr2r5URVi + + + + + _16232574195069562409.type mCFi9E_vI1Gu0XHzlnh_m + mStXIwIR8KAAv6ARccOAw + + CV_8UC1 mliO2qNZyubKtP7in1Ssn + + + + + + _3177068552073086628 moanVKLjBkBg7dMlJPONL + + _16232574195069562409 mbt5SAyJ0i6W4bLawdt57 + + + + mutBU3VL4kbmyoDhYw433 + + + cv m_XDfKwHIauqxlIfd7ek8 + +cvtColor mpjzV4KZxaQDwr2r5URVi + + + + _16232574195069562409, _3177068552073086628, CV_BGR2GRAY mIDskT2Ezu2SmjrRoylFV + + mImOQ30xzOc_uNsHyP8iG + + + + + cv mefjDpa1uzvEFh4mie_ed threshold mpjzV4KZxaQDwr2r5URVi + + + _3177068552073086628, _3177068552073086628, 125, 255, cv meRaDcNwfpCk5n9grUGX7 + + THRESH_BINARY | cv mZELcoRtBrp7Sft8tq6Ou THRESH_OTSU mrlcYflEp9xH4DwhHAWUs mbt5SAyJ0i6W4bLawdt57 + + + + + + + std mefjDpa1uzvEFh4mie_ed + + + map mkiU7yX8zJtw_v46BRkzD + + + + + + uint32_t,std mnqFMJGRhgjvp_pZ5IOOv + + + vector myaJWyz9JD5MGaWvI0QFx + + + +uint64_t mcjLnHRwXSEJ2o4zZUusJ + + + mDXBwAJFHOvHVaiZ7AF_H + + _14914440896847872494 mUv5kY_Bm0YLXNMIvvPWg + + + + mpCILpVV4vUBNDy5lSVOw + + mLrr0I4aMBrFW4U7lBkAH + + &_6120577810974659803:_12481497024245504838 mIDskT2Ezu2SmjrRoylFV + + + + mnAwzWCKr4Ngi4iXzcGr8 + + + mkchMRxQpTPBDn9C571le + + _15906990838572784608 mQfZIJDgBU3BdGapYz1bV + + + + _6120577810974659803.first mnvogmkgJi8s_xT4F6F8R + + + + + std mnqFMJGRhgjvp_pZ5IOOv + + vector mFhEQbVP1lNGzbnF221nk + + + + + +uint64_t mZtAmBsslWUS22rG8kZ1b + + + _5268611906072959724 mtX8hC56Rij3zXBqmxZp8 + + + + + _8865077727849858911 mpjzV4KZxaQDwr2r5URVi + + + + + + _3177068552073086628,_15906990838572784608,_5268611906072959724 mliO2qNZyubKtP7in1Ssn + + mtX8hC56Rij3zXBqmxZp8 + m__TMRASLw93PPGE2yn7M + + + + mGzqmpNwk4mr3E0dvvjSM + + + + + +_5268611906072959724.size mNMRj6wDhQ93dxqegLtvt + + + + + mq3dvPVyqQqzoivCNRbWr + + + + + + 0 mbcrGRuvRtqW4iEXkTUcW + + mSu4rh5czbliAfrWfnYhZ + + + + + mLnaLj_1Gbq0KlxM63ttX + + mXx6k9ZG22M9fuTaNBTIc + _5268611906072959724 mYdP8kipOkT4ieI5McrJa + 0 ms6zRfqQITtRJuBxd7ez3 + + + + mSKSlQP3SrmyO06AafLZj + + +0 mjTTWGVy7GF1IXYDhoZE8 + mSu4rh5czbliAfrWfnYhZ + + + + + + _14914440896847872494 m_V14bOiRiIxDrlTqWYtS + + + _15906990838572784608 mjS0lJNsw1G90SmlQY5qB + + + + mi1E1JOOoJBHvNwXGlNZP + + + + _5268611906072959724 mUv5kY_Bm0YLXNMIvvPWg + mUTL6eJxLtsjrupXE2X81 + + mnhn7UL6et5NpOpJg8_3F + + mI91H7PcIeHOQZaA3fXOW + + + + mXN4CKvjNXNZl7HvRiZco + + + + + + mozT9Zgu6ZTK3LKX60Y9X _14914440896847872494.size mCEQ0TEicvxnHNWNJj4it + + + + + + mGU1ngQr7JiLginN19yJQ + + + 0 mDDnm0lVEEXfpMuHGpj8g + + mIgPpecNCyRRT3HdGHUn4 + mP3JqrbdyzkPpFAt_xYKB + + mmCaJ3KGd7NNmPlcwQF1O + + + mXjcKpRAn6nJd638eBBFR + mMmWX8h7QqfSL9VSOlfNA + + + + + _15906990838572784608:_14914440896847872494 mDDnm0lVEEXfpMuHGpj8g + + + mpPZZZbLtagf8omLASRfj + + + + + + + const mdhwTWTMu1icjDi9hfqlA + &_5268611906072959724 mQfZIJDgBU3BdGapYz1bV + + _15906990838572784608.second mmCaJ3KGd7NNmPlcwQF1O + + + + + mphR03KjkbvJ9sy13EtjP + + + + + + mlKS3U9iIvrKxK25CSDB4 + + + +&_5268605282119983834:_12481497024245504838 m_V14bOiRiIxDrlTqWYtS _15906990838572784608.first mqoMxZnTfbfYBoTn0nJV8 + + + + + + mtwGgc5GrChJ20supQjgN + + + mdaCm9YE4t6O8fELFMMu4 + + + + mzAHKEUDwtqpasfB_HPW3 + + + ms7Jo9iQdD1ZZmNmk3a1e + _5268611907152064295 mQfZIJDgBU3BdGapYz1bV + + + + +0 mUv5kY_Bm0YLXNMIvvPWg + + _5268611907152064295 mFY7zdHONGcRzFzoyY8kr + + 4 mQhUPedX62xqEPHfzQGcc + + _5268611907152064295 myZa9IkYioVRg5FYLlaiO + mrlcYflEp9xH4DwhHAWUs + + + miozH_cApnlsVVUTj7wmg + mpjzV4KZxaQDwr2r5URVi + + _5268605282119983834 mWXfXe51g9WAJ8QIohvis + + is md6BvuIcgygpgfKlysgZJ + + + + _5268611906072959724 mjkt5w2w1CPQA77xbaGHR + _5268611907152064295 myd6LkUouNB5_CBOoCU0P + mbcrGRuvRtqW4iEXkTUcW + + + + + + mrlcYflEp9xH4DwhHAWUs + + + + mSu4rh5czbliAfrWfnYhZ + + + _2394613391546474355 mcmHAJZwf8LvY5eozlZjb + + + _5268611907152064295 mnvogmkgJi8s_xT4F6F8R + + + _14831471554986028865 mA_9KI4DgbsDsYQAEgoY2 + + _5268605282119983834 mzNO9uWo9w9JHl16INSLV + + + + + + at mALQrwGTaPCuUQpxn8goh + + + + _5268611906072959724 mSFSgMrzYJ2aycmXuZ_UN + + _5268611907152064295 myd6LkUouNB5_CBOoCU0P + + + + + + mYqLYtnarrwfKPCZuAhAO + mcz9vG5JNpazF2dx78RRR + + + _13962554610986522386 mi1E1JOOoJBHvNwXGlNZP + + + + + + _5268605282119983834 mzsVSfaoLsyM4zZT0WE0R +getName mK8NxQzpqlpB0VMDVFXXW + + mmCaJ3KGd7NNmPlcwQF1O + + + + meFrW56FKtDOIEsxZSBBd + mVer_WamOoYy01Hwvga1p + + + + + mammOMg1Em7gIMHty_XyS + + + + + mI91H7PcIeHOQZaA3fXOW + + + mx2zEH0A38Vu06txsW4ce + mAWuzTlg24YUBSoPsZ9vh + + + + + + _13104684682841805604 mf6BXrh_hM3Lu_j1rlwq1 + + + + 0 mtwGgc5GrChJ20supQjgN + + + + + + + mpPZZZbLtagf8omLASRfj + + mnWe2WMZRc8fSBGNkevEY + + + + +_14439806665537672147 mi1E1JOOoJBHvNwXGlNZP + + + + + + static_cast mPJnJSYXLmdIbnFUwNHSF + mgmKNyQT_98kYMMsZi04t +mq3dvPVyqQqzoivCNRbWr + + mGzqmpNwk4mr3E0dvvjSM + + + + + + static_cast mEJ1Wmys3R7G4aUbtSDtJ + + m_mRKxCd12wCQvo6Wuw4S +mD9QkwifLlOs9pXc9J63h + + + mpjzV4KZxaQDwr2r5URVi + + + + + + _5268605282119983834 mZHorJXpPCfTjWt6RV13U tau mg0PwPuKB6C7zRioyJn53 + + + mtwGgc5GrChJ20supQjgN + + * _13104684682841805604 mYqLYtnarrwfKPCZuAhAO + + + mcz9vG5JNpazF2dx78RRR + + mH91xA57x3eJDeOPO6rru + + msMWW0IQhVwqQ2YacqdgA + + mMmWX8h7QqfSL9VSOlfNA + + + + _16232574195068687893 : _5268605282119983834 m_599PypIhfUF_mW7eHRN + + + getMapCode mCEQ0TEicvxnHNWNJj4it + + mRsgOf47LQXIC7pqr3f_z + + + + + mdaCm9YE4t6O8fELFMMu4 + + + + + + mhsVevT8PJMhDImpSwr4S + + + + mpjzV4KZxaQDwr2r5URVi + + + + + mbDQ34yk53dYVGBc5ttxA + _13303058356268144138 mJCuTzDrLaCIb_4NcR6Pp + + 0 mtX8hC56Rij3zXBqmxZp8 + + + + + + _13303058356268144138 mkiU7yX8zJtw_v46BRkzD + + 4 mtX8hC56Rij3zXBqmxZp8 + + _13303058356268144138 mvLHp90GrSnXD2Fr_yYfS + + + + + + mDDnm0lVEEXfpMuHGpj8g + + + + + + + mhI91PnryIh5KGIgwPF6z + + + mjLkzURBgb5j4kht4W_Zd + + msMWW0IQhVwqQ2YacqdgA + + + + hamm_distance msMWW0IQhVwqQ2YacqdgA + + + + _16232574195068687893.first, _5268611906072959724 mjkt5w2w1CPQA77xbaGHR + + _13303058356268144138 mXVgEuURMTp4fhE7NddKQ + + + + + + mDDnm0lVEEXfpMuHGpj8g + + mPJnJSYXLmdIbnFUwNHSF _14439806665537672147 mm1GYvBFNYJsFht34T1x4 + + + + + mdaCm9YE4t6O8fELFMMu4 + + _14831471554986028865 mA_9KI4DgbsDsYQAEgoY2 + + + _16232574195068687893.second mImOQ30xzOc_uNsHyP8iG + + _2394613391546474355 msWGAMn7MMcvcGOlXDrOU + + _13303058356268144138 mQhUPedX62xqEPHfzQGcc + + + _13962554610986522386 mJJ6iijAn8_6SlW8lFvD6 + _5268605282119983834 mZHorJXpPCfTjWt6RV13U + + + + + + getName mR7mWPVa8MiSAgRfzG29b + + mUv5kY_Bm0YLXNMIvvPWg + + + + + + + mitZZIhLsWsu9skRw1jFj mQl2ldI2tj8cteuHkaRTS + + mmCaJ3KGd7NNmPlcwQF1O + + mrHATcpdatrnGgRa0FZRi + + + + + + + mwC8XLCAtchCv5UC_siZu + + + mBK4AfDd6rNwliYNVDno6 + + + mI91H7PcIeHOQZaA3fXOW + + + mOYUL6jMctMmuYeHFSDLp + + + + + mj283d7HAayAVqS_PJAGf + + mPIAYksK3EcKmgJxbBzem + + + mcWvQOF1cx6ayOeD120aY + + + mmCaJ3KGd7NNmPlcwQF1O + + mI91H7PcIeHOQZaA3fXOW + + + + + + + mhCfBMV_sTdybeorCIcWK + DictionaryBased meRaDcNwfpCk5n9grUGX7 + + + + _8865077727849858911 mGzqmpNwk4mr3E0dvvjSM + + + + + const cv mEoyyspRNdei6c_EzFQhy + Mat& _16984303577840393047, ms27HQswJ5SXmPWrH4NWz + + + + + +_10390503492195675259, std mbEo_Mk94ki_m4g3tTVoE + vector mIBMllFEz9Ypr14f7K59G + + uint64_t mq3dvPVyqQqzoivCNRbWr + + + + + + & _5268611906072959724 mm1GYvBFNYJsFht34T1x4 + mhI91PnryIh5KGIgwPF6z + + + + + + + mODxb_fdZiIAsvJ8YUU1E + + + _13359095126362812111 mcmHAJZwf8LvY5eozlZjb + + + static_cast mEJ1Wmys3R7G4aUbtSDtJ + + + + mbDQ34yk53dYVGBc5ttxA + + + + + + mf6BXrh_hM3Lu_j1rlwq1 + + + + + + mk8wKFOnj49iAJd4aDkZt + + + + std mEoyyspRNdei6c_EzFQhy + + sqrt md6BvuIcgygpgfKlysgZJ + _10390503492195675259 mrlcYflEp9xH4DwhHAWUs + + + + mYqLYtnarrwfKPCZuAhAO + mbt5SAyJ0i6W4bLawdt57 + + mnWe2WMZRc8fSBGNkevEY +_16652114979004670745 mJJ6iijAn8_6SlW8lFvD6 + + + + + _13359095126362812111 + 2 mUv5kY_Bm0YLXNMIvvPWg + + + + + + + cv mEoyyspRNdei6c_EzFQhy + + + + Mat _15192065210330273017 mf4DuSNLl0XPL3uNNL2rH + + + _16652114979004670745,_16652114979004670745,CV_32SC1 mbcrGRuvRtqW4iEXkTUcW + + + + + + mnvogmkgJi8s_xT4F6F8R + + cv mX08yh_QwWY_mAf7x8k_Y + Mat _11711985297635095136 mozT9Zgu6ZTK3LKX60Y9X + + + _16652114979004670745,_16652114979004670745,CV_32SC1 mIDskT2Ezu2SmjrRoylFV + + + mcz9vG5JNpazF2dx78RRR + + + + + + _15192065210330273017.setTo mk8wKFOnj49iAJd4aDkZt + + + + +cv mX08yh_QwWY_mAf7x8k_Y + + + +Scalar mPHKtUJ8uz46jwxT06PRH + + + all mpjzV4KZxaQDwr2r5URVi + + 0 mbcrGRuvRtqW4iEXkTUcW + + mliO2qNZyubKtP7in1Ssn + mQhUPedX62xqEPHfzQGcc + + + + + + _11711985297635095136.setTo mGzqmpNwk4mr3E0dvvjSM + + + + + + cv m_XDfKwHIauqxlIfd7ek8 + Scalar mefjDpa1uzvEFh4mie_ed + + + + all md6BvuIcgygpgfKlysgZJ + + + + 0 mDDnm0lVEEXfpMuHGpj8g mIDskT2Ezu2SmjrRoylFV + + mcz9vG5JNpazF2dx78RRR + + + + mu4ydSMiHEctax4kYVdb9 + + mozT9Zgu6ZTK3LKX60Y9X + + mnWe2WMZRc8fSBGNkevEY + _13303058356268144023 mJCuTzDrLaCIb_4NcR6Pp + + + + + + 0 mULYTQpaey1FyazHeWxOh + + + + + _13303058356268144023 mrJP7yXQ3gfs8BNPhcKEy + + + + _16984303577840393047.rows mImOQ30xzOc_uNsHyP8iG _13303058356268144023 mpQF1UkY07SbDa13HMVXL + mliO2qNZyubKtP7in1Ssn + + + mSu4rh5czbliAfrWfnYhZ + + const uchar *_5268605234499577910 mcmHAJZwf8LvY5eozlZjb + + + _16984303577840393047.ptr mkiU7yX8zJtw_v46BRkzD uchar mpo1ZqsJmgLR7QfLt2Svu + + + + + md6BvuIcgygpgfKlysgZJ _13303058356268144023 mYqLYtnarrwfKPCZuAhAO + mbt5SAyJ0i6W4bLawdt57 + + + + + + + ms7Jo9iQdD1ZZmNmk3a1e +_16232574195041802241 mJCuTzDrLaCIb_4NcR6Pp + mWUCBzjZdDs5rjSUmVr1H + + + + msMWW0IQhVwqQ2YacqdgA + _16652114979004670745 mm1GYvBFNYJsFht34T1x4 + + *float mAWuzTlg24YUBSoPsZ9vh _13303058356268144023 mDDnm0lVEEXfpMuHGpj8g +/ mCF9L9Vf7mnqETg9dtDIS + + + + + + mpjzV4KZxaQDwr2r5URVi _16984303577840393047.rows mliO2qNZyubKtP7in1Ssn + + + + mImOQ30xzOc_uNsHyP8iG + + mhsVevT8PJMhDImpSwr4S + + + + + + md6BvuIcgygpgfKlysgZJ + mpURwZr6RkzcBE20jWxFb + + + + +_13303058356268144065 mi1E1JOOoJBHvNwXGlNZP + 0 mUv5kY_Bm0YLXNMIvvPWg + + + + _13303058356268144065 myaJWyz9JD5MGaWvI0QFx + _16984303577840393047.cols mUv5kY_Bm0YLXNMIvvPWg _13303058356268144065 mBRlQW2l1b4lBNK6gW3CP + + + + mliO2qNZyubKtP7in1Ssn + + + + mbKNUqK669FqBXCA3lJyM + + mbDQ34yk53dYVGBc5ttxA + + + + _16232574195041802242 mTfc0rqffOgoI2NHBOVxn + + + + mn3hAXUeOUwS6PfAoy0qU + mGzqmpNwk4mr3E0dvvjSM + _16652114979004670745 mIDskT2Ezu2SmjrRoylFV + + + *float mALQrwGTaPCuUQpxn8goh + + + _13303058356268144065 mRsgOf47LQXIC7pqr3f_z + + + + + + / mIF_WMyGU5Lcml6CnI6qJ + + mXx6k9ZG22M9fuTaNBTIc + + _16984303577840393047.cols mliO2qNZyubKtP7in1Ssn mammOMg1Em7gIMHty_XyS + + + mdmgzNgGOQUa3qNC7dQN_ + + + + _5268605234499577910 mKdeu4SPbLs4BtwBBp5BV + + + + _13303058356268144065 mqoMxZnTfbfYBoTn0nJV8 + mcjLnHRwXSEJ2o4zZUusJ + + + + 125 mtwGgc5GrChJ20supQjgN + + + _15192065210330273017.at mrJP7yXQ3gfs8BNPhcKEy + + + + ms7Jo9iQdD1ZZmNmk3a1e + + mZtAmBsslWUS22rG8kZ1b + msMWW0IQhVwqQ2YacqdgA + + _16232574195041802241,_16232574195041802242 mIDskT2Ezu2SmjrRoylFV + + + + + + mrowniYvbzUpleOokSjRY + + + + + + mnvogmkgJi8s_xT4F6F8R + _11711985297635095136.at mEJ1Wmys3R7G4aUbtSDtJ + + + mpURwZr6RkzcBE20jWxFb + + mD9QkwifLlOs9pXc9J63h + + mk8wKFOnj49iAJd4aDkZt + _16232574195041802241,_16232574195041802242 mrlcYflEp9xH4DwhHAWUs + myZa9IkYioVRg5FYLlaiO + mmCaJ3KGd7NNmPlcwQF1O + + + + + + mI91H7PcIeHOQZaA3fXOW + + + + + + + mj283d7HAayAVqS_PJAGf + + + cv m_XDfKwHIauqxlIfd7ek8 + + + Mat _135647812390791080 mALQrwGTaPCuUQpxn8goh + + + + _16652114979004670745,_16652114979004670745,CV_8UC1 mYqLYtnarrwfKPCZuAhAO + mtX8hC56Rij3zXBqmxZp8 + + + + + mpCILpVV4vUBNDy5lSVOw + + mbDQ34yk53dYVGBc5ttxA + + + + + _13303058356268144023 mGeQISP1_6bWC2BggNsHP + 0 mtX8hC56Rij3zXBqmxZp8 + + +_13303058356268144023 mrJP7yXQ3gfs8BNPhcKEy + + + + _16652114979004670745 mmCaJ3KGd7NNmPlcwQF1O + _13303058356268144023 muqj3O4pxoCHIqQ5CZBHQ + + + mjTTWGVy7GF1IXYDhoZE8 + + + + + + + mjh0sa9bFWohEDiGYP1AK + + + mbDQ34yk53dYVGBc5ttxA + _13303058356268144065 mJCuTzDrLaCIb_4NcR6Pp + + + + + 0 mmCaJ3KGd7NNmPlcwQF1O + + + _13303058356268144065 mEJ1Wmys3R7G4aUbtSDtJ + _16652114979004670745 mQhUPedX62xqEPHfzQGcc + + _13303058356268144065 mBRlQW2l1b4lBNK6gW3CP mRsgOf47LQXIC7pqr3f_z + + mSu4rh5czbliAfrWfnYhZ + milBFUekrY6cYcZ1RQ3PZ + + + + + _15192065210330273017.at mWlpDId3FIhqgc7jVSsf3 + + + + mb5PxDwPgyfZumEYuHMg_ + mdeUvvdfSeGNTY1mHvR2j md6BvuIcgygpgfKlysgZJ + + + + +_13303058356268144023,_13303058356268144065 mjTTWGVy7GF1IXYDhoZE8 + mDXBwAJFHOvHVaiZ7AF_H + + + + + + _11711985297635095136.at mkiU7yX8zJtw_v46BRkzD + + + mnWe2WMZRc8fSBGNkevEY + + mhQWrdtJCP8CtBdxGMq92 + + + + mf4DuSNLl0XPL3uNNL2rH _13303058356268144023,_13303058356268144065 mbcrGRuvRtqW4iEXkTUcW + + + /2 mRsgOf47LQXIC7pqr3f_z + + + + + _135647812390791080.at mkiU7yX8zJtw_v46BRkzD + uchar mpo1ZqsJmgLR7QfLt2Svu mGzqmpNwk4mr3E0dvvjSM _13303058356268144023,_13303058356268144065 mtwGgc5GrChJ20supQjgN + + + + + + mJJ6iijAn8_6SlW8lFvD6 + + + + + + 1 mcz9vG5JNpazF2dx78RRR + else + _135647812390791080.at mFhEQbVP1lNGzbnF221nk + + uchar mZtAmBsslWUS22rG8kZ1b + + + + + + mGzqmpNwk4mr3E0dvvjSM + + + + _13303058356268144023,_13303058356268144065 mtwGgc5GrChJ20supQjgN + moanVKLjBkBg7dMlJPONL + + +0 mnvogmkgJi8s_xT4F6F8R + + + + + + + mBK4AfDd6rNwliYNVDno6 + + + + + mhKjc0R9XSbNgt_iqsmxH + + mf4DuSNLl0XPL3uNNL2rH + + mbDQ34yk53dYVGBc5ttxA + +_13303058356268144023 mQfZIJDgBU3BdGapYz1bV + + 0 mImOQ30xzOc_uNsHyP8iG + + _13303058356268144023 mkiU7yX8zJtw_v46BRkzD + _16652114979004670745 mbt5SAyJ0i6W4bLawdt57 + _13303058356268144023 mP_bC3onF3BTl0J3VYWNw + + + mjTTWGVy7GF1IXYDhoZE8 + + + + + mdaCm9YE4t6O8fELFMMu4 + + + + mbDQ34yk53dYVGBc5ttxA + + + + _5268611906073170262 mJJ6iijAn8_6SlW8lFvD6 + + + + _16652114979004670745 - 1 mULYTQpaey1FyazHeWxOh + + + + mYULjLQFJyrr4Q2mAhNNT + + md6BvuIcgygpgfKlysgZJ + + _13303058356268144023 mZHPxe26JeGM_JP2l8E3l + + 0 mUFbkQ4Dp7BOF3JOKxO7r + + + _13303058356268144023 mStXIwIR8KAAv6ARccOAw + + + + _16652114979004670745 - 1 mDDnm0lVEEXfpMuHGpj8g + + _5268611906073170262 mcmHAJZwf8LvY5eozlZjb + + + + 1 mmCaJ3KGd7NNmPlcwQF1O + + + mhsVevT8PJMhDImpSwr4S + + + mpjzV4KZxaQDwr2r5URVi + mbDQ34yk53dYVGBc5ttxA + _13303058356268144065 mQfZIJDgBU3BdGapYz1bV + + 0 mnvogmkgJi8s_xT4F6F8R + + _13303058356268144065 mEJ1Wmys3R7G4aUbtSDtJ + _16652114979004670745 mImOQ30xzOc_uNsHyP8iG + _13303058356268144065 mFK6149xLldB4_yaXLtr9 _5268611906073170262 mDDnm0lVEEXfpMuHGpj8g + + + + mYULjLQFJyrr4Q2mAhNNT + + + + + mk8wKFOnj49iAJd4aDkZt + + _135647812390791080.at mEJ1Wmys3R7G4aUbtSDtJ + + +uchar mD9QkwifLlOs9pXc9J63h + mALQrwGTaPCuUQpxn8goh + + + _13303058356268144023,_13303058356268144065 mrlcYflEp9xH4DwhHAWUs mSKSlQP3SrmyO06AafLZj + + + 0 mjTTWGVy7GF1IXYDhoZE8 + + + + mglJrCDsuRZOfs4rHlEmx mT5wnqjLMSe3dhvAOfE8s + + + mnvogmkgJi8s_xT4F6F8R + mI91H7PcIeHOQZaA3fXOW + + + cv mKToG9ROo9WUGKuycfIEh + Mat _12291663728371552149 mozT9Zgu6ZTK3LKX60Y9X + _13359095126362812111,_13359095126362812111,CV_8UC1 mRsgOf47LQXIC7pqr3f_z + + + + + + mcz9vG5JNpazF2dx78RRR + + + + mXjcKpRAn6nJd638eBBFR + + ms27HQswJ5SXmPWrH4NWz + _13303058356268144023 mcmHAJZwf8LvY5eozlZjb + 0 mImOQ30xzOc_uNsHyP8iG _13303058356268144023 mEJ1Wmys3R7G4aUbtSDtJ + + +_13359095126362812111 mULYTQpaey1FyazHeWxOh + + _13303058356268144023 mBRlQW2l1b4lBNK6gW3CP + + + + + + mtwGgc5GrChJ20supQjgN + mbTkoiXVRfTqO3ABVKxa7 + + ms7Jo9iQdD1ZZmNmk3a1e _13303058356268144065 moanVKLjBkBg7dMlJPONL 0 mUv5kY_Bm0YLXNMIvvPWg +_13303058356268144065 mPJnJSYXLmdIbnFUwNHSF + + + + _13359095126362812111 mmCaJ3KGd7NNmPlcwQF1O + + _13303058356268144065 muqj3O4pxoCHIqQ5CZBHQ + + mYqLYtnarrwfKPCZuAhAO + + + + + _12291663728371552149.at mEFwg3vEAf3XVyaZqswfd + + + + + + uchar mdeUvvdfSeGNTY1mHvR2j + + + + mpjzV4KZxaQDwr2r5URVi + + _13303058356268144023,_13303058356268144065 mrlcYflEp9xH4DwhHAWUs + + + + + msWGAMn7MMcvcGOlXDrOU + +_135647812390791080.at mIBMllFEz9Ypr14f7K59G + + uchar mvrIbmYybi_XyoDIj5afd mGzqmpNwk4mr3E0dvvjSM + + _13303058356268144023+1,_13303058356268144065+1 mIDskT2Ezu2SmjrRoylFV + + + mQhUPedX62xqEPHfzQGcc + + + + + + + mnWe2WMZRc8fSBGNkevEY + + _16232574195041797857 mGeQISP1_6bWC2BggNsHP + + + + 0 mULYTQpaey1FyazHeWxOh + do + mzmOqJvsTZVQidJCvDeGj + + + + + + _5268611906072959724.push_back mAWuzTlg24YUBSoPsZ9vh + +_798059623973164676 mf4DuSNLl0XPL3uNNL2rH + + _12291663728371552149 mRsgOf47LQXIC7pqr3f_z + + + mtwGgc5GrChJ20supQjgN mmCaJ3KGd7NNmPlcwQF1O + + + + + _12291663728371552149 mA_9KI4DgbsDsYQAEgoY2 + + _17232963975139041229 mk8wKFOnj49iAJd4aDkZt + + _12291663728371552149 mRsgOf47LQXIC7pqr3f_z + + + + + + mbt5SAyJ0i6W4bLawdt57 + + + + _16232574195041797857 mvLHp90GrSnXD2Fr_yYfS + + + mcz9vG5JNpazF2dx78RRR + + mBK4AfDd6rNwliYNVDno6 + + while mGzqmpNwk4mr3E0dvvjSM + + _16232574195041797857 mEFwg3vEAf3XVyaZqswfd + + + 4 mYqLYtnarrwfKPCZuAhAO + + + + + + mbt5SAyJ0i6W4bLawdt57 + + + + mI8eq3D_3tnA6CgHBUBue + + mUDC0uNfijVGKLtsMbFj6 +mQhUPedX62xqEPHfzQGcc + + + + + + + mBK4AfDd6rNwliYNVDno6 + + uint64_t DictionaryBased mX08yh_QwWY_mAf7x8k_Y + _798059623973164676 mGzqmpNwk4mr3E0dvvjSM + + const cv mPHKtUJ8uz46jwxT06PRH + + + +Mat& _3175967589417851225 mIDskT2Ezu2SmjrRoylFV + + + mnAwzWCKr4Ngi4iXzcGr8 + + std mPHKtUJ8uz46jwxT06PRH + +bitset mIBMllFEz9Ypr14f7K59G + 64 mDXBwAJFHOvHVaiZ7AF_H + + + + + + _3175967376566488426 mmCaJ3KGd7NNmPlcwQF1O + + + + mIPU11YvvW3aYEM3OeTXb + _3175967376566505202 mcmHAJZwf8LvY5eozlZjb + + + 0 mammOMg1Em7gIMHty_XyS + + + + + + + mZrbyqxLBc0k3KIuHGEQ7 + + + + mpjzV4KZxaQDwr2r5URVi + + + mb5PxDwPgyfZumEYuHMg_ + + + + _13303058356268144023 mQfZIJDgBU3BdGapYz1bV + + + _3175967589417851225.rows - 1 mQhUPedX62xqEPHfzQGcc + + + + + + _13303058356268144023 mwa5remO28hlDpKwcBBWS + + + + + 0 mnvogmkgJi8s_xT4F6F8R + + + _13303058356268144023 mkhyx7xB8UcnN5cefHRjm + + + + mDDnm0lVEEXfpMuHGpj8g + + + mZrbyqxLBc0k3KIuHGEQ7 + mpjzV4KZxaQDwr2r5URVi + + + mODxb_fdZiIAsvJ8YUU1E + + + + _13303058356268144065 mcmHAJZwf8LvY5eozlZjb + + _3175967589417851225.cols - 1 mammOMg1Em7gIMHty_XyS + + + + + + _13303058356268144065 mwa5remO28hlDpKwcBBWS + 0 mQhUPedX62xqEPHfzQGcc _13303058356268144065 mlntG7S_lpYCVq4bRbYPo + + + + mbcrGRuvRtqW4iEXkTUcW + + + _3175967376566488426 mKdeu4SPbLs4BtwBBp5BV + _3175967376566505202 myZa9IkYioVRg5FYLlaiO + + + + mA69cEVFqqg0MTsOOvkJS + mJCuTzDrLaCIb_4NcR6Pp + _3175967589417851225.at mkiU7yX8zJtw_v46BRkzD + + + + + uchar mpo1ZqsJmgLR7QfLt2Svu + + + mf4DuSNLl0XPL3uNNL2rH + +_13303058356268144023, _13303058356268144065 mliO2qNZyubKtP7in1Ssn + + + + + mnvogmkgJi8s_xT4F6F8R + + + + + + + mW1HNzsoA3Q_zzpQgmLOJ + + + + _3175967376566488426.to_ullong mYrGZrWb07kXUx_r_u6l4 + + mQhUPedX62xqEPHfzQGcc + + + + + mBK4AfDd6rNwliYNVDno6 + + cv mbEo_Mk94ki_m4g3tTVoE + + + + Mat DictionaryBased mefjDpa1uzvEFh4mie_ed + + + + _17232963975139041229 mozT9Zgu6ZTK3LKX60Y9X + + + const cv mnqFMJGRhgjvp_pZ5IOOv + + + Mat& _16232574195069562409 mDDnm0lVEEXfpMuHGpj8g + + mpPZZZbLtagf8omLASRfj + + + + + cv mbEo_Mk94ki_m4g3tTVoE + Mat _5268605234504081842 mbt5SAyJ0i6W4bLawdt57 + + + + _16232574195069562409.copyTo mGzqmpNwk4mr3E0dvvjSM + + +_5268605234504081842 mm1GYvBFNYJsFht34T1x4 + + + + + + mQhUPedX62xqEPHfzQGcc + + + + + + myW2ZEtR0oj8fAEzMOKhf + + + mGzqmpNwk4mr3E0dvvjSM + + mb5PxDwPgyfZumEYuHMg_ + _13303058356268144138 mJJ6iijAn8_6SlW8lFvD6 + + + + 0 mULYTQpaey1FyazHeWxOh + + _13303058356268144138 mrJP7yXQ3gfs8BNPhcKEy + _16232574195069562409.rows mQhUPedX62xqEPHfzQGcc + + + + _13303058356268144138 mKc5UWB3zedeuenjAQP3x + + mRsgOf47LQXIC7pqr3f_z + + + mTvkQaeoomlJ_VTYKUxKs + + + + mbkdZa3VP6wJBnBgkWY0T + + + + + + mALQrwGTaPCuUQpxn8goh + + mODxb_fdZiIAsvJ8YUU1E + + + + _13303058356268144139 mA_9KI4DgbsDsYQAEgoY2 + + + + + 0 mUv5kY_Bm0YLXNMIvvPWg + _13303058356268144139 mEFwg3vEAf3XVyaZqswfd + + + _16232574195069562409.cols mtX8hC56Rij3zXBqmxZp8 + + + + + + _13303058356268144139 mP_bC3onF3BTl0J3VYWNw + mrlcYflEp9xH4DwhHAWUs + + mTvkQaeoomlJ_VTYKUxKs + + + + + _5268605234504081842.at mFhEQbVP1lNGzbnF221nk + + + + + uchar mf6BXrh_hM3Lu_j1rlwq1 + + + + mXx6k9ZG22M9fuTaNBTIc + + + + +_13303058356268144138, _13303058356268144139 mRsgOf47LQXIC7pqr3f_z + mGeQISP1_6bWC2BggNsHP + + _16232574195069562409.at myaJWyz9JD5MGaWvI0QFx + + uchar mdeUvvdfSeGNTY1mHvR2j + + + + msMWW0IQhVwqQ2YacqdgA + + + + + _16232574195069562409.cols - _13303058356268144139 - 1, _13303058356268144138 mjTTWGVy7GF1IXYDhoZE8 + + + + + + mnvogmkgJi8s_xT4F6F8R + + mUTL6eJxLtsjrupXE2X81 + + mI91H7PcIeHOQZaA3fXOW + + + meFrW56FKtDOIEsxZSBBd + _5268605234504081842 mtX8hC56Rij3zXBqmxZp8 + + mUXFYtjkeWrs0H7mYy9Zz + + + + mwC8XLCAtchCv5UC_siZu + +#ifdef _6297270708729154545 +#undef mKc5UWB3zedeuenjAQP3x +#undef mvJCJ8LrCi0JO7BsL7cgO +#undef mf8y3OBUdXH2bvxPyg_r7 +#undef mMGUXQCWK2DVivHkk30Vn +#undef mf6BXrh_hM3Lu_j1rlwq1 +#undef mAvTK0fLYBO1PwbzhDC7l4LUJlT5i3u +#undef mk8wKFOnj49iAJd4aDkZt +#undef mDHWpiI_tGXw6RzcfqVwptHtWJCC6Eg +#undef mvLICAGv487TCIBPwRkax +#undef mt8L46vdf60jtmGev7NhD +#undef mBK4AfDd6rNwliYNVDno6 +#undef mu4GMnrSgnNZH5KkWj0cs +#undef mQy7Ve62WRZBxHgGipfE0 +#undef mdaCm9YE4t6O8fELFMMu4 +#undef mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg +#undef mfMwn8m1i5quGvbIlKykw +#undef mVM3Tnyk6EGttlw0sJM0s +#undef mtZ5IYPsC48lZ1JYvHaN23szjFLc2Gm +#undef mXN4CKvjNXNZl7HvRiZco +#undef mZtAmBsslWUS22rG8kZ1b +#undef magXSvaK7SHbBe_LkH4_4 +#undef maAB0ww2vPqS4fYcksIE4 +#undef m_BdtoOIG1cGfXQ010uG9 +#undef mUXFYtjkeWrs0H7mYy9Zz +#undef mhsVevT8PJMhDImpSwr4S +#undef mrJP7yXQ3gfs8BNPhcKEy +#undef mOcCrtCXPX_jF07MJcw9n +#undef mm1GYvBFNYJsFht34T1x4 +#undef mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8 +#undef mGjhh4Vxe8OxVrJr0ifTO +#undef mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1 +#undef mI_VxTqt1y9E8RYyv32oX +#undef mVrCPn74N7uV5WhnsGZJq +#undef mYbIeXvlXENIPQHHILIaB +#undef mmfFwPQA1xPQv6ZDDj4T71WKygJoUng +#undef mYm1jXwOzznj6v1tE5IOH +#undef mi2B4Lz_N8qgRBsjRhZog +#undef mUFbkQ4Dp7BOF3JOKxO7r +#undef mgZoaqza5nUMJX7kSjaPt +#undef mRQZ5PRNkTFHe67OFkdim +#undef mHVlQj0u7m3qO8vVCjWPY +#undef mQXJkXZ92dFmt3nhFohj7 +#undef maXg6kKb6KP5M_pbADCJlzqNDlLgcew +#undef mJCDmcrP01LC6ub2hGy3o +#undef mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH +#undef mDBb_5ji8TzqfiVcwoXmy +#undef my24077tijd722rF1VIYj +#undef msneHAqwwPFAFhfiPn59i +#undef mhKjc0R9XSbNgt_iqsmxH +#undef mpHrH5FQw2SHugb9qnWzf +#undef mHkoiNP3iqdLbzVDX73gnq6piKxsrhA +#undef mWpzfBNpgUkhHKOjjpigm +#undef mnvogmkgJi8s_xT4F6F8R +#undef mHRtOIH8m5To877qqzoRn +#undef mdm8QhxsL_by8IUn_NfLe +#undef mG7pANqob65nAnzu7i4jI +#undef mFk9QjJB88E3T3eqrw6Hk +#undef mXDDzvxmbbYJFWCaREXxP +#undef mi1E1JOOoJBHvNwXGlNZP +#undef mvcFLyGSLDfAyP0Jpx19q +#undef mqoMxZnTfbfYBoTn0nJV8 +#undef mbbDN_Rpy5B5MjStWvpqa +#undef mvaG5Eyy4oCUwLhlO56Fm +#undef mZrbyqxLBc0k3KIuHGEQ7 +#undef m_7xnaPD2PNoybbmxMeJM +#undef mKdeu4SPbLs4BtwBBp5BV +#undef mOb1aYb7F6YnFLW0bMjfR +#undef mK9iBInm1aQyyeRIM6ZeG +#undef mvmm5bcQmzwx8NHg0XtMY +#undef mWofT82dkoxcrXjA4clne +#undef mHbaBgi1nxDavbkI8XP9n +#undef mutBU3VL4kbmyoDhYw433 +#undef muiH2m02EdZG3W26VSQSN +#undef mq7ITy8QmbBXM460Q_Xz5 +#undef mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI +#undef msfuU7ZJA0EB9ByaYzGjN +#undef mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu +#undef mr535LNebOcWpbsHNcM4a +#undef mjSpE7GvJHAKhzusbafPB +#undef mbUT5LzRbyNtndMkZH0UT +#undef mjdKtLdSdZkJmraP0G2WP +#undef mKbed25gQfvyglUad1I2k +#undef mGPli8AOiz4d5L9v8Yrp_ +#undef mGIrYNW2isKVFfktOjTqK +#undef mqMqVRAd_aKvw7DAVTP2_ +#undef mliwe0HGLMppNs2ic2StI +#undef mgK1nBhC8d0CONy9jztqh +#undef mB3MiIZnjJO4hcfDJr7Fd +#undef mXjcKpRAn6nJd638eBBFR +#undef mHlO3rVlumDU7QarN5DVh +#undef mmro5kjl9hnK3vhryhusC +#undef mze0XvTZWjGhFxgMavYSK +#undef mRsgOf47LQXIC7pqr3f_z +#undef mF69qLuHuU1JWaGCkeIPC +#undef mXoUt82ohV6cUrmrZvMYN +#undef mX08yh_QwWY_mAf7x8k_Y +#undef mdUlEEbPea1atW0GHbpNZ +#undef mJmLMshPna77IHase49uXfPadGq2sqg +#undef mKbjkcrZ29WrTmHduNvYA +#undef mitZZIhLsWsu9skRw1jFj +#undef msdXnwGLNioMb_WsjosEm +#undef mytEm5wA3qJhLdNxzOUPNkvvAX6w1gS +#undef mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9 +#undef mPvm6SUNl3QEbNWtKla3D_vB0HYM9an +#undef mwC8XLCAtchCv5UC_siZu +#undef mY1nnZpqGLf_KAJGU2cEj +#undef mqHTHqkaFbETBHVUoXJWE +#undef mnqFMJGRhgjvp_pZ5IOOv +#undef mMXjdiIeIvGA_jW3bUAjlYbzT09U4a8 +#undef mL3pQ2P5JemQ53ZNDgnYJ +#undef mXVgEuURMTp4fhE7NddKQ +#undef mV_JO_GYxvSxhU4uLY1OM +#undef mEqbSmgVZr5FajsveqAaosx7AnWiosb +#undef mKGCgkw_i3WVepYOOBV5x +#undef mLJPu8lXj19Fryu1ZZwyB +#undef mrGyaUsf1rTFyLHAMEVqr +#undef m_aLkQCeXTOJC9TSYHqNk +#undef mUv5kY_Bm0YLXNMIvvPWg +#undef mACj5aDbo51D21ozBlOr3 +#undef mjwEUUCjtQgEnewvWx8fl4AQuuZ3bih +#undef mCrMF6fE7ESIHQFH0dEIJ +#undef mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE +#undef mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T +#undef mfwb3_g4Sz8VqjsiIbIvG +#undef mmGgXpzWHS0goyBtjaUqC +#undef mGRuvgzGl9XlDtmWWPeUK +#undef mNRyjOhB7Dxhr5nSwV35B +#undef mtX8hC56Rij3zXBqmxZp8 +#undef meVfpMBWdlHHiNPtZOu97 +#undef myb8XWBN13SLgutfqt0dbdsZb3LhWzd +#undef mwa5remO28hlDpKwcBBWS +#undef moxVzlkRFdhpZIl6K380D +#undef mz9o7QRiicNuHtnBEMOD7 +#undef mjMIjYcagrDIhgRHLBLJ7 +#undef mbSdwawBuj90bQJR6WIph +#undef mE0vjCGwyO_EuShAyS8iC +#undef ma6S6MAu1NwBvwcsRucH2 +#undef mcmHAJZwf8LvY5eozlZjb +#undef mGU1ngQr7JiLginN19yJQ +#undef ms6zRfqQITtRJuBxd7ez3 +#undef mAaJU5xxEW1CYbXZQizTM +#undef mpo1ZqsJmgLR7QfLt2Svu +#undef mSKSlQP3SrmyO06AafLZj +#undef maPJlF9eKfdZpUMBWRHkTrUBpKDJ0co +#undef mqPbItOg03dxQmSR2Uk3fmpgZz_klvF +#undef mdR4KdDQS_UNB8q5GwCTp +#undef mqEhfU__oa9DCvMpGl7xD +#undef mSE0j7t7H5EAb_ZhVdwIK +#undef mtWEyCsPBvsskTgpOAqp1 +#undef mv9B5FsaH2yXRdC540TI5 +#undef mcWvQOF1cx6ayOeD120aY +#undef msvj1WdNRCWQnU7kPB8st +#undef m_V14bOiRiIxDrlTqWYtS +#undef mPJnJSYXLmdIbnFUwNHSF +#undef mTNOuXm2Jm9miwDjb5tyx +#undef m_QQCR7XByf2N0sZhsT1N +#undef mlBMGNFS1VBnwA37erYVq +#undef mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd +#undef mrpUZcBGxsetRWKsiyWx4 +#undef mJuc8ZstMJCWG5iyEXaN3 +#undef mJoyyUKrNBL6Ql5t_pTvk +#undef mIPU11YvvW3aYEM3OeTXb +#undef mq9TrLjBjxHKe3exYN9eE +#undef mDOtyv4fPSDYxOiDLEl95 +#undef mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL +#undef mZHPxe26JeGM_JP2l8E3l +#undef mllTE_QcE8U1uguTDh7N5Erewe_C598 +#undef mw8os29O3XjXaPwf0zALv +#undef mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793 +#undef mA2iqL31fN9OUGw4jozAN +#undef mWO7OzY4w1RQi65oEUUsF +#undef mgE4qbPnyXc3efkHO82jq +#undef mR0HAl9a1y7f8gVhVfAwG +#undef mcFBvJvXtblQX6Fg2ApcE +#undef mJ47yGydM9YmPe4hychyfQA7aKca0Ad +#undef mDXBwAJFHOvHVaiZ7AF_H +#undef mTwOJQ81rZ7MRaawk9Uu9 +#undef mfjRPTOF4giaARD6lhoMVLbGOxFWm8T +#undef mnAS51UogwBmVXrl9vmGJ +#undef miHDLzVSKvARra6Y01hWr +#undef mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk +#undef mSduIqcv605DvBK13Cm_Y +#undef mUXzfsBItfAkAJO_t7lfO +#undef mhCfBMV_sTdybeorCIcWK +#undef mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF +#undef mlKS3U9iIvrKxK25CSDB4 +#undef mOYUL6jMctMmuYeHFSDLp +#undef mUYrvQEzcig7b1zvxhPy1 +#undef m_599PypIhfUF_mW7eHRN +#undef mEoyyspRNdei6c_EzFQhy +#undef ma74Qo28qWqot2ZIS3Fyr +#undef mNTw8HzUNkW8_DTYH4gpwL7LUaQMKKf +#undef mRtOqOvSdgzN_V8FvpnHb +#undef mBW3NFYv2beayxbQvFLGW +#undef mwXriqi6ed862tk3jeahD +#undef mIhOz6EDelav78AgCeqLs +#undef mwH2GJGhLu088iewfAD59 +#undef mQtvQSwrNiYvwhfS52Y03 +#undef mfJD50JfpgrShRXqYhIZl +#undef mzmOqJvsTZVQidJCvDeGj +#undef mf83dcpJKOzkjjHopMCOV +#undef mEHzt2j27I_r9ArZFtU3k +#undef md3vd0U7tLQ6v9n8QKDU5 +#undef mdhwTWTMu1icjDi9hfqlA +#undef ms27HQswJ5SXmPWrH4NWz +#undef mfFQARR3_tIZW5XTTQU1A +#undef mMrHUxwvIwBTwtW3jowYK +#undef m_XDfKwHIauqxlIfd7ek8 +#undef mXNzU4nQb5cjZ5qt3FS1d +#undef mLnaLj_1Gbq0KlxM63ttX +#undef mfI5sjTcOplXcd7j6ZnOD +#undef mRXwBwdyRkw7aKRylJs66ypo1B_m_0F +#undef mlntG7S_lpYCVq4bRbYPo +#undef mPojCKJrQdGKYp70sKqT_ +#undef maSOhW6VVHr304WwlTjWn +#undef mALQrwGTaPCuUQpxn8goh +#undef mliO2qNZyubKtP7in1Ssn +#undef mbTkoiXVRfTqO3ABVKxa7 +#undef mA69cEVFqqg0MTsOOvkJS +#undef mYdP8kipOkT4ieI5McrJa +#undef mtKX4jlpKTaFUkWN47ndG +#undef mMdziLP8WcbwaMcssN9B8 +#undef mvkheICyC35AIAYDw4Zyq +#undef mctUyWmD0XJ5N4OQ9mZpY +#undef maeXo0rOyzBRmw_0Wa4Dh +#undef mFmcFT5tNPDxxtAQDRygO +#undef mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA +#undef mqChal7Lpd5NyrwU9_65CoRxYpFEsER +#undef mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF +#undef mbcrGRuvRtqW4iEXkTUcW +#undef mlnUl9HS21ij8prFFUOm9 +#undef mr_t0VU07rCpnf18ja3VQH4hAgihcOS +#undef mrHATcpdatrnGgRa0FZRi +#undef mX_z0wj8ObIIq9af09sC0 +#undef mWUCBzjZdDs5rjSUmVr1H +#undef mFmNeG2Rpi_LZC9ZW38ef +#undef mqLVU73RNF9YUYdPCcll22ViBN9SF2U +#undef mDYLg07CKdRe94Gq6NImk +#undef mJyzDEHjlSfqY7l1wMFeQ +#undef mY6tJ9W8wInfV4RYeEKp2 +#undef mFY7zdHONGcRzFzoyY8kr +#undef mfJ2LcgqSYHSC2c1T7SAE +#undef mvrIbmYybi_XyoDIj5afd +#undef mozT9Zgu6ZTK3LKX60Y9X +#undef mggutP_yHyWvu0Ekk1mwRC04lWUwd_m +#undef mxsRDiqVXLBNzw01QQxKX +#undef mioXCuayzgDdWhSRWKLed +#undef mmCaJ3KGd7NNmPlcwQF1O +#undef mCFi9E_vI1Gu0XHzlnh_m +#undef m_JXNpnZDnAp5khrQSXjapYF6lfAR0B +#undef mJYtrRsE2uYggeWjY2LP3 +#undef mtZx8lvascnf58_HYyrR_ +#undef mSFSgMrzYJ2aycmXuZ_UN +#undef mIDskT2Ezu2SmjrRoylFV +#undef mc_OCvzP6VsuLl8dMwGOm +#undef mh5qvlH8wVKxm6A4h6vev +#undef mAMDw3_zRMVylvtXnIjBsVy3Dy3HHW2 +#undef mWx09TAhXLwzZg6gvY1wW +#undef mtHrBAzZTGKvOl81mghBInh7SZskJmF +#undef mStXIwIR8KAAv6ARccOAw +#undef mWtU95iFpkzn0xmGdbIAh +#undef mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC +#undef mzAHKEUDwtqpasfB_HPW3 +#undef mgwxQeWxI56dH2g2_WWpD +#undef mLjILzpM9YuUBIsOQCW3JTZ8vrgI7Ew +#undef mUfPIu8Vb9gD5sEwHX4e5 +#undef mh9e6vcSYz6HnQe4fqomg +#undef mAeOOYtJLjtiZrAejurqE +#undef mI91H7PcIeHOQZaA3fXOW +#undef mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa +#undef meRaDcNwfpCk5n9grUGX7 +#undef mpnKBQc4vnaBXkhRtMEEp +#undef m_5TwoouoplXp1WfLBglcjt1EhIy1BP +#undef mUpFtzfKEDtly_CqCQ0PF +#undef mc3Hj19nsRMEiMbeHvUCU +#undef mpjzV4KZxaQDwr2r5URVi +#undef mTDBGBjeJLsSP8S0ojrcp +#undef miozH_cApnlsVVUTj7wmg +#undef myd6LkUouNB5_CBOoCU0P +#undef mphR03KjkbvJ9sy13EtjP +#undef mw7lfYFyssbL7Av32ucdk +#undef mkyxRd57ezpBkOmagYqTAZD11hc5iiZ +#undef mBuO1nGdSHpu4TSluhT4O +#undef mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd +#undef mdmgzNgGOQUa3qNC7dQN_ +#undef mlQdFjl0ooqvqHRZqYcyj +#undef mjS0lJNsw1G90SmlQY5qB +#undef mpCILpVV4vUBNDy5lSVOw +#undef mglJrCDsuRZOfs4rHlEmx +#undef mqefBAW94jsu9t4XeRAb4 +#undef mzsVSfaoLsyM4zZT0WE0R +#undef mlV8Y9_shvYNeI5NWUEsQ +#undef m_luBFxDlc6u5AWaSNY1d9c4swLNOfY +#undef mvLHp90GrSnXD2Fr_yYfS +#undef maEnSWEgWazQCv6CHPBdU1mwuubq_P5 +#undef mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM +#undef mOff4CUepSLCQVBkkB4bz +#undef mNMRj6wDhQ93dxqegLtvt +#undef mAYtYaN6dbp9zBOK9UF5z +#undef mjKATjaOSsq_6M1Yq0edS +#undef mBztK6cUpomzSRkmuQGnZ +#undef mIgPpecNCyRRT3HdGHUn4 +#undef mcukTcF4A7NiUzDApj4RG +#undef mbKNUqK669FqBXCA3lJyM +#undef mTgzHHwnMyvSh5WWkkQS4 +#undef mbDQ34yk53dYVGBc5ttxA +#undef mKBHZJWEfbe20zc_948AG_nFL4Ai5rj +#undef mzNO9uWo9w9JHl16INSLV +#undef mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV +#undef mWlpDId3FIhqgc7jVSsf3 +#undef mdfThLoMV5tIdQ2swrG8L +#undef mmXXfYKCpX5tnhwHy0cga +#undef mLuiVq_3te7z9xsD97om2 +#undef mh_eDgfDp08_MvU2cXe75 +#undef mFbR2FVRb8mnXb2NxYr4v +#undef mhecrOoYCTyuTlKM26PxE +#undef mJLrAGp8dQbittTYE_Ivmi_lBtah608 +#undef mZ6vZGHETO5UcSJpJp6N6 +#undef mZzMXQdeguzHjXEXNO1QK +#undef mJe0oYBaM_aL82ifqLZxf +#undef mid8aHTF65cJMaoUCgSTAguSfvQZEPI +#undef mnnUjNItdkxSYMAOyNXJ4 +#undef mT5wnqjLMSe3dhvAOfE8s +#undef mBRlQW2l1b4lBNK6gW3CP +#undef mA_9KI4DgbsDsYQAEgoY2 +#undef mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw +#undef mvy4kfrik3LTb2UaVSo3v +#undef mewoJ48WbzL6zXIiSQBBU +#undef mJ9KJghgi70k5kym1xGdg +#undef mXx6k9ZG22M9fuTaNBTIc +#undef mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy +#undef mfLAQEin6tuee1y5ARv7i +#undef m_S9C9Y7k3GlCHSRI6FGL +#undef msGsNiQdWnMrcIqK9l52p +#undef mXhnm50_jYpsgSiCD7j2i +#undef mjkt5w2w1CPQA77xbaGHR +#undef mGzqmpNwk4mr3E0dvvjSM +#undef mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK +#undef mXveLotP6FhAl4PMM4j_S +#undef m_XaXsk15o_nT7QVQuKoA +#undef mtwGgc5GrChJ20supQjgN +#undef mcjLnHRwXSEJ2o4zZUusJ +#undef mD5B9pkA89EC4f1Qc82A5 +#undef miWz_Ze4VI0S39LDIvV52 +#undef mMTZq37nKqAui22kDhqeR +#undef mMyvQy9EqcjbvEaQE_B0serMYsW_6c3 +#undef mepOW63ynkxIWHChbUIEj +#undef mQ1ZN9j2cHu8wO429pRIz +#undef mzitAd_hTqhzNCLjWYp1j +#undef mEfNmy3uLww0qsY8zk775 +#undef mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m +#undef mJJ6iijAn8_6SlW8lFvD6 +#undef mK8NxQzpqlpB0VMDVFXXW +#undef mw9jjid_2JyKztWEjEg1A +#undef mw0Dj_Yezs39GQeLmR7OY +#undef mV8SfHwiFeXXGt_yu3qHa +#undef mfPJMiSs5agSiG0ZqPxxR +#undef mYULjLQFJyrr4Q2mAhNNT +#undef mnhn7UL6et5NpOpJg8_3F +#undef mdeUvvdfSeGNTY1mHvR2j +#undef mQU6d0_1K0In64fJWtbiG +#undef mk1BJOHVaWt0_ucVb9zjh +#undef mocMt7k1d6hH36IrOJAqh +#undef mX27P9WXq5drMAiURlKk0udqdeLbg7e +#undef ma1lgnuL8HqB3QcBftqAb +#undef mtMAjwlPEjEFdJaEmSack +#undef mlm_9oXhlTuerkYDO2Ttt +#undef mkIRDfPZDhe1BVtFFdF1S +#undef mJobVgCApuWWKSDxZaaDN +#undef mf5pjP0xaFTKIkU4XGsdg8688P96n1o +#undef m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN +#undef mBzIPzCUkGzNHOHhJdtOo +#undef mkgznqllrZG0plUbFzXOi +#undef mfG5f3LQBIeimwuOnhtlH +#undef mQl2ldI2tj8cteuHkaRTS +#undef mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ +#undef m_4jN8sQ6DEmiIyaoBHT3 +#undef mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw +#undef mhI91PnryIh5KGIgwPF6z +#undef mYO8W_MVWmBxye06RAssu +#undef mYqLYtnarrwfKPCZuAhAO +#undef mXXMimcHa_p5YaY4A3yKq +#undef mDKyMPGQYHeFqQcIiCmQ4 +#undef mrowniYvbzUpleOokSjRY +#undef mULYTQpaey1FyazHeWxOh +#undef mODxb_fdZiIAsvJ8YUU1E +#undef mkiU7yX8zJtw_v46BRkzD +#undef mIuaYkUO_dkyAY1Wr_vDh +#undef myaJWyz9JD5MGaWvI0QFx +#undef mLrr0I4aMBrFW4U7lBkAH +#undef mj283d7HAayAVqS_PJAGf +#undef mbEo_Mk94ki_m4g3tTVoE +#undef mqDJjsFqDv3jM6v1jy6hs +#undef mpQF1UkY07SbDa13HMVXL +#undef mKy8rw4xP4On93uCwHF4D2U62HCL3Io +#undef mD9QkwifLlOs9pXc9J63h +#undef mlMERM1wFnAQtxwJQWQnC +#undef mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f +#undef mmIcWL3CRXYN7vGBrnWtP +#undef mI8eq3D_3tnA6CgHBUBue +#undef mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR +#undef mIaLxSop23sAP_vIqOnv1 +#undef md3om5i8JMXvGl5JEe2Vu +#undef mMmWX8h7QqfSL9VSOlfNA +#undef mFl0t8a00ojjudatDpPZsuu_Eq19F_n +#undef mP3JqrbdyzkPpFAt_xYKB +#undef moanVKLjBkBg7dMlJPONL +#undef mKgHN3HY1bzeTSs1pEynF +#undef mW1HNzsoA3Q_zzpQgmLOJ +#undef mUTL6eJxLtsjrupXE2X81 +#undef mZysRumux6MYdAiBN8m_6 +#undef mMQ3ZxVrbLvUzSYMZleNY +#undef mcz9vG5JNpazF2dx78RRR +#undef mbkdZa3VP6wJBnBgkWY0T +#undef mFlcxzWknoLUXDpxe6_Je +#undef mf4DuSNLl0XPL3uNNL2rH +#undef mFHkCJmDB1L21SfZ1Pxoj +#undef mUvlnXTpeugHwHQHMzfZ0 +#undef miNghrPSTdiwFttm9u32tuKr6WWT7qI +#undef ma8G1mxuzZkia5XUhr2Qx +#undef mZELcoRtBrp7Sft8tq6Ou +#undef mOAryzLN3HVsT5qmgV2AkpTCYz_kbih +#undef mSu4rh5czbliAfrWfnYhZ +#undef mvIxxyQb8LsZZhCMBaG8W +#undef ma3XrqU_S3mKrUh1JrWMu +#undef mPHKtUJ8uz46jwxT06PRH +#undef msWGAMn7MMcvcGOlXDrOU +#undef mHn9cGoFVoy7QSoSlfiah +#undef mQfZIJDgBU3BdGapYz1bV +#undef mDNV2FHy_lkQ7z6xqTf1l +#undef mP0pVwuZkPkvAuAdWvU4_ +#undef mSkvFMg6etBh7j0u9moo1 +#undef mnzhaVe5dD1sSXD8Jge1e +#undef mIkFrTlZUNR1ErSGJVWAx +#undef mDDnm0lVEEXfpMuHGpj8g +#undef mFK6149xLldB4_yaXLtr9 +#undef muqj3O4pxoCHIqQ5CZBHQ +#undef mu4ydSMiHEctax4kYVdb9 +#undef mT2nbuAv30cuyUs8IHJny +#undef mf331x1xTK9tce2SlF0sr +#undef mCZ7sjmjv2BCj0YG4N3CG +#undef mEfikwAmC9bnMfEYbXO09 +#undef mImOQ30xzOc_uNsHyP8iG +#undef msMWW0IQhVwqQ2YacqdgA +#undef mR8iByj9XMcGVN5u7YTSb +#undef mwA3oiyLhQkH3yLR5Li_g +#undef mJJA7PLbdXe2O1WRDb27F +#undef mwwc7bFP2zAqn3NWQGes3 +#undef muwYtJb_5EG5b3vjnx3Cf +#undef mc1MFFMhQ7jVqBFJi9Nr3 +#undef mTuUfWvG4K2bsU48V2zio +#undef mX5yd6fs3ig80svoLdcIe +#undef mQhFAFV1kXmW0_GxvR2MU +#undef mjLkzURBgb5j4kht4W_Zd +#undef m_8QOFZoAfV61xnNXIIpS +#undef ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs +#undef mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe +#undef mTfc0rqffOgoI2NHBOVxn +#undef mJFnvYYDXG7K4WBM5ACFP +#undef mUeX4f7PPnrxsqkCLt0EF +#undef mx2zEH0A38Vu06txsW4ce +#undef mJu7v95xnmVTk9dTlJ_7X +#undef mKjnEYQcGM3c5JLpihMiM +#undef mNDp5F8xkVrBXvD5gWOMK +#undef mdH_De6HWypwxBwHhRgi_ +#undef mjEFqg9MiDYQCsDmsCPzd +#undef mKToG9ROo9WUGKuycfIEh +#undef m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ +#undef ms7Jo9iQdD1ZZmNmk3a1e +#undef mQQ4_JXq5zIQzcr216CQM +#undef mPIAYksK3EcKmgJxbBzem +#undef m_mRKxCd12wCQvo6Wuw4S +#undef mQOrDnmnesi3Z_CeSFCDD +#undef mrBOj_dqOG8M7DUjNzuOchGnNCkB5NO +#undef mdqghzFLKp4V4RmfR6N5Y +#undef mIBMllFEz9Ypr14f7K59G +#undef mY6Fre4Gb1htKl088hUat +#undef mgYUY_asiYZ_KoKWxX8ay +#undef mzjF8yGeGnLf_MyYFKQtg +#undef mLmLxQimmNePFf0xuzaHFIcdzJBPG6e +#undef mwlfRgKcuQknJqq6hUMLH +#undef mKZuT0uyFvPMYGXsafAjN +#undef mOqWQ9tXhWn2K_pjI6LPi +#undef myZa9IkYioVRg5FYLlaiO +#undef mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN +#undef mGTbUnMlsMqq6GhVnJ0hS +#undef mImWrs_HISgL5mOIzhWMU +#undef mFXRMwax4IeKL8bMO8alL +#undef mi0OK1qKXnOqyzpiMfAGY +#undef mUDC0uNfijVGKLtsMbFj6 +#undef mrlcYflEp9xH4DwhHAWUs +#undef mT7IYtMHjxAUbRSF3WiYH +#undef meViGlslynNIAOuZbgJ_p +#undef mKmONRDV3IUoBl43lzUcW +#undef mR7mWPVa8MiSAgRfzG29b +#undef mkchMRxQpTPBDn9C571le +#undef mynZZllKb44ONZwVsaeM7oF68mkvMxF +#undef mnAwzWCKr4Ngi4iXzcGr8 +#undef mjh0sa9bFWohEDiGYP1AK +#undef mpP2ijXZLFoSQTgzMxzKR +#undef mEcYfGz02eHy9i6Gsrslo +#undef mZIEX8Rqly8XLjMtgRxwo +#undef mjDWQpsL5G7AJJ8uckK28 +#undef mZ82AM4h3bybtyqGC6Pmc +#undef mIF_WMyGU5Lcml6CnI6qJ +#undef mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf +#undef mcxtQXId4G3krUUn5jqav +#undef mAWuzTlg24YUBSoPsZ9vh +#undef myW2ZEtR0oj8fAEzMOKhf +#undef mFhEQbVP1lNGzbnF221nk +#undef mS8tKayqrnVhdPp9OTHYa +#undef mEFwg3vEAf3XVyaZqswfd +#undef mZHorJXpPCfTjWt6RV13U +#undef mRTf4mOIWnLDoCGKeVqsT +#undef mu2MzKUX2WOqiUPVfcF_k +#undef mjTTWGVy7GF1IXYDhoZE8 +#undef mrIAD45ahQxB4XxHqS0oY +#undef mPJErRyupABJq8s9bUtIn7GTWAGE9sm +#undef mAEWaLnyn6TaDDpFZX0qM +#undef mMUQqv7FvvOeM8XxbXiVS +#undef mgJgPGKXuHawCrXU8Ico4 +#undef mi1Q7duZPyUCvmYdi18Rr +#undef mIEHEqU7E59VGmbUfQQSaBEACixI8KT +#undef mhiwO1Skg6_RvJxulvkVn +#undef mFfNp9GHFFOrr0Ts67Gk0 +#undef mb5PxDwPgyfZumEYuHMg_ +#undef mpPZZZbLtagf8omLASRfj +#undef mpURwZr6RkzcBE20jWxFb +#undef mGeQISP1_6bWC2BggNsHP +#undef mrlPjE0rBiYZu22PsGWYO +#undef mowjdPUwQBO8ke4dgrDbs +#undef mZ10R1pf0ctEfbjhQvbV8 +#undef mnRcrFlY2pRxaCpbt2ixOGHrHbidKsd +#undef msmJmE3BI9nTqPActW4WcrG4rKxB5za +#undef mefjDpa1uzvEFh4mie_ed +#undef mDingNqrCQ45PwqQCEeZp +#undef meFrW56FKtDOIEsxZSBBd +#undef mTXFlCgqYmMgzfy59s6GB +#undef mTdxd70lotLGo3DmCPBSaOO5WAEIgA4 +#undef mWXfXe51g9WAJ8QIohvis +#undef mabJg_wp04tpCSI7xI1Rk +#undef mHVC31pGMfJlHGtp4NgI9 +#undef mIxlPIVpOuLHyQyNm0ihe +#undef mKst1rlMhDK1HGBpdPkyR +#undef mRKa8M3EpERyXIS4Rf5VN +#undef mQhUPedX62xqEPHfzQGcc +#undef mhQWrdtJCP8CtBdxGMq92 +#undef mn3hAXUeOUwS6PfAoy0qU +#undef mZVcND24pRyHsiHHLYH0_ +#undef mdq43P0warNCRS2zfOPZFhFeIoZUk8k +#undef mEJ1Wmys3R7G4aUbtSDtJ +#undef mYrGZrWb07kXUx_r_u6l4 +#undef mTvkQaeoomlJ_VTYKUxKs +#undef mm5aIJdLIBsAB77cxV436 +#undef mdPVlh1hYUgUmjUgzk3Tg +#undef mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI +#undef mz45HxoFSkI70BknPihHQ +#undef mC08krF57_pyhCoe2ONfK +#undef mSOvZoTs4qjWxdPUtdRvFuEMDZojLt1 +#undef mcM8wZPr4Vtj58J5J7aRj +#undef mjuNTF9Txp7lPRofQiC2H +#undef mwr64HqIGhAhAgoAgEC9v +#undef mac1Y1_F_pN80Tywc7tSb +#undef mUAkJQHrQ7EZenDvUsmSU +#undef mTWjW0rpbdswTmzo8Z3LB +#undef mhk5uGUobIyf1xLEH_2bD +#undef mwQNk6XWIL7WA81O03b1I9pWX7PNbFF +#undef mCEQ0TEicvxnHNWNJj4it +#undef myJF7GpiX67xE_58NSAvN +#undef mOYKWpAyqxWO_GV2pYGCv +#undef mkhyx7xB8UcnN5cefHRjm +#undef mc651sVlXl9J65e77j2GS +#undef milBFUekrY6cYcZ1RQ3PZ +#undef m__TMRASLw93PPGE2yn7M +#undef mJCuTzDrLaCIb_4NcR6Pp +#undef mWX5gLI6KjLyLV2WAX5AE +#undef mVer_WamOoYy01Hwvga1p +#undef my4awox2tCnzHvXYtOI1H +#undef miqVJ3bEFxKyuX8OX2N1uheDYf2htom +#undef mNumnROIqNRPfMGdnOSdL +#undef mGlUHuHNjQdSGPeFhZid3vDS8xVvCf9 +#undef mRjUl0ZokWDm2XjUj4PfGoKZXq2nSHo +#undef mdBss3RRkpb7YIc0jMlr7 +#undef mlyBoXug_w1GD49fr8e5z +#undef md6BvuIcgygpgfKlysgZJ +#undef mgmKNyQT_98kYMMsZi04t +#undef mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x +#undef mf7iqWeGGCD6aYpnxAcbn +#undef mTb1oltaFl_dANTG3sBsz +#undef meQKw5xOO97WFLVSiO_nA +#undef mtSiEKIxgJ6zdfdVVeElV +#undef mwnxVsUQpXrjB3ZuLLzI9 +#undef mHSId6f45t6UiNWMLtmYbe__RTBOjYn +#undef mw1j28pJsrVGbBGyqXMF_ +#undef mP_bC3onF3BTl0J3VYWNw +#undef mP0yU3Y1ig5H5pZfFknTL +#undef mVnOY8YcCNILdUUkXbXrJ +#undef mg0PwPuKB6C7zRioyJn53 +#undef mjIZeI_2FJbzRNDLoFbdQ +#undef mlXUQdlKoCAw7mj1xBwdu +#undef mMpkV46e5oVMOHQgQLmhH +#undef mmPyu4Xr9bvkikStyPb1K +#undef mzzWLGuJwRKKsLsF1T9l0 +#undef mNpGy4cpAWZjLdRTMv9XrZjoteoC1c6 +#undef mpIxvxw4n63AIoOknaWlK +#undef miYxq_2sY3wPlGLLB52ri +#undef mq3dvPVyqQqzoivCNRbWr +#undef mHMHsPJzciJS12kVag5LO +#undef mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y +#undef mhSri3zo8skOv0F7a_y2RVdEct4r117 +#undef mbt5SAyJ0i6W4bLawdt57 +#undef msk_FrOJpViselc2WPwu8pmFVqgnKM7 +#undef mCF9L9Vf7mnqETg9dtDIS +#undef mvHaWyT4_NbVmbaESYvT4 +#undef mVfw6LLvSTbOwJ452n65F +#undef mKfil14pm2HQtt2J7Xh0t +#undef mER9zKhVzbRXCJtJ3ghTAidOqKbAASN +#undef mY0wzkY1CPIkMtQNAcAih +#undef mKaZdCTQiDOYndULWMefF +#undef mbHo0qB2zVKJgbcw5rqzf +#undef mMmT6oHofsd_MjGVNAWLf +#undef mammOMg1Em7gIMHty_XyS +#undef mH91xA57x3eJDeOPO6rru +#undef mNjYzzpcDr5hR8qGA_Fpu +#undef mD0IbSBwhOl7k23vsbh1D +#undef mo5p_TjqasZCNRrNK8ihqOf98NylVc0 +#undef mwe8NMWXTOOJQZbLd8hd9 +#undef mRMSNkyg2m73s2xgeT02S +#undef mnWe2WMZRc8fSBGNkevEY +#undef mvLno4xhrC1_3QBB0uaRG +#endif + +#ifdef _6297270708729154545 +#undef mw1j28pJsrVGbBGyqXMF_ +#undef mTDBGBjeJLsSP8S0ojrcp +#undef mTfc0rqffOgoI2NHBOVxn +#undef mQhUPedX62xqEPHfzQGcc +#undef mbkdZa3VP6wJBnBgkWY0T +#undef maPJlF9eKfdZpUMBWRHkTrUBpKDJ0co +#undef mTuUfWvG4K2bsU48V2zio +#undef mnAS51UogwBmVXrl9vmGJ +#undef mn3hAXUeOUwS6PfAoy0qU +#undef mER9zKhVzbRXCJtJ3ghTAidOqKbAASN +#undef mKgHN3HY1bzeTSs1pEynF +#undef mXoUt82ohV6cUrmrZvMYN +#undef mLrr0I4aMBrFW4U7lBkAH +#undef mqMqVRAd_aKvw7DAVTP2_ +#undef mfJD50JfpgrShRXqYhIZl +#undef mSu4rh5czbliAfrWfnYhZ +#undef mIkFrTlZUNR1ErSGJVWAx +#undef mnTvtgRMn1TDHfrt2m9yChnXCtBJYwM +#undef mNpGy4cpAWZjLdRTMv9XrZjoteoC1c6 +#undef mjwEUUCjtQgEnewvWx8fl4AQuuZ3bih +#undef mHbaBgi1nxDavbkI8XP9n +#undef mnWe2WMZRc8fSBGNkevEY +#undef mgmKNyQT_98kYMMsZi04t +#undef mpo1ZqsJmgLR7QfLt2Svu +#undef mNumnROIqNRPfMGdnOSdL +#undef mUpFtzfKEDtly_CqCQ0PF +#undef mcjLnHRwXSEJ2o4zZUusJ +#undef mT5wnqjLMSe3dhvAOfE8s +#undef mRtOqOvSdgzN_V8FvpnHb +#undef mvLno4xhrC1_3QBB0uaRG +#undef mSjwTpBwpgGbr5Ax3RpQbDxr2CDouAI +#undef mJFnvYYDXG7K4WBM5ACFP +#undef mjkt5w2w1CPQA77xbaGHR +#undef mQU6d0_1K0In64fJWtbiG +#undef mDHWpiI_tGXw6RzcfqVwptHtWJCC6Eg +#undef mJYtrRsE2uYggeWjY2LP3 +#undef maAB0ww2vPqS4fYcksIE4 +#undef mJfp6Kbni2Psqk2PTY_vMO1ffsYtNFk +#undef mHSId6f45t6UiNWMLtmYbe__RTBOjYn +#undef m_5TwoouoplXp1WfLBglcjt1EhIy1BP +#undef mSFSgMrzYJ2aycmXuZ_UN +#undef ms6zRfqQITtRJuBxd7ez3 +#undef mHVlQj0u7m3qO8vVCjWPY +#undef mmGgXpzWHS0goyBtjaUqC +#undef mTwOJQ81rZ7MRaawk9Uu9 +#undef mPojCKJrQdGKYp70sKqT_ +#undef mKjnEYQcGM3c5JLpihMiM +#undef mdm8QhxsL_by8IUn_NfLe +#undef mfPJMiSs5agSiG0ZqPxxR +#undef mRQZ5PRNkTFHe67OFkdim +#undef mHn9cGoFVoy7QSoSlfiah +#undef mz45HxoFSkI70BknPihHQ +#undef mUeX4f7PPnrxsqkCLt0EF +#undef mOb1aYb7F6YnFLW0bMjfR +#undef mwA3oiyLhQkH3yLR5Li_g +#undef ms27HQswJ5SXmPWrH4NWz +#undef mwZB7NdHw7ucAjdLBjDe38O1jGj0H0m +#undef mefjDpa1uzvEFh4mie_ed +#undef mwe8NMWXTOOJQZbLd8hd9 +#undef mIEHEqU7E59VGmbUfQQSaBEACixI8KT +#undef mjh0sa9bFWohEDiGYP1AK +#undef mf7iqWeGGCD6aYpnxAcbn +#undef mglJrCDsuRZOfs4rHlEmx +#undef mWO7OzY4w1RQi65oEUUsF +#undef mXjcKpRAn6nJd638eBBFR +#undef mhaGaYHvbFNPYVNI5sXzSkuSOQG_LzV +#undef maXg6kKb6KP5M_pbADCJlzqNDlLgcew +#undef mXNzU4nQb5cjZ5qt3FS1d +#undef miNghrPSTdiwFttm9u32tuKr6WWT7qI +#undef mUv5kY_Bm0YLXNMIvvPWg +#undef mytEm5wA3qJhLdNxzOUPNkvvAX6w1gS +#undef mbt5SAyJ0i6W4bLawdt57 +#undef mTWjW0rpbdswTmzo8Z3LB +#undef mqPbItOg03dxQmSR2Uk3fmpgZz_klvF +#undef mnhn7UL6et5NpOpJg8_3F +#undef mGjhh4Vxe8OxVrJr0ifTO +#undef mqefBAW94jsu9t4XeRAb4 +#undef mT2nbuAv30cuyUs8IHJny +#undef mTvkQaeoomlJ_VTYKUxKs +#undef mKy8rw4xP4On93uCwHF4D2U62HCL3Io +#undef mFlcxzWknoLUXDpxe6_Je +#undef mzzWLGuJwRKKsLsF1T9l0 +#undef mD5B9pkA89EC4f1Qc82A5 +#undef mmXXfYKCpX5tnhwHy0cga +#undef mlBMGNFS1VBnwA37erYVq +#undef mIgPpecNCyRRT3HdGHUn4 +#undef mRsgOf47LQXIC7pqr3f_z +#undef mO83cCL0HWrmZ4HQB2j8fjSwdJVwBAa +#undef mXhnm50_jYpsgSiCD7j2i +#undef mKBHZJWEfbe20zc_948AG_nFL4Ai5rj +#undef mJ47yGydM9YmPe4hychyfQA7aKca0Ad +#undef mjMIjYcagrDIhgRHLBLJ7 +#undef mKc5UWB3zedeuenjAQP3x +#undef mYm1jXwOzznj6v1tE5IOH +#undef mKdeu4SPbLs4BtwBBp5BV +#undef mzsVSfaoLsyM4zZT0WE0R +#undef mGlUHuHNjQdSGPeFhZid3vDS8xVvCf9 +#undef mh9e6vcSYz6HnQe4fqomg +#undef mnzhaVe5dD1sSXD8Jge1e +#undef mbHo0qB2zVKJgbcw5rqzf +#undef mKZuT0uyFvPMYGXsafAjN +#undef mY0wzkY1CPIkMtQNAcAih +#undef mUDC0uNfijVGKLtsMbFj6 +#undef mIhOz6EDelav78AgCeqLs +#undef mKbed25gQfvyglUad1I2k +#undef mGIrYNW2isKVFfktOjTqK +#undef mEHzt2j27I_r9ArZFtU3k +#undef mFXRMwax4IeKL8bMO8alL +#undef mnvogmkgJi8s_xT4F6F8R +#undef mPHKtUJ8uz46jwxT06PRH +#undef mEfNmy3uLww0qsY8zk775 +#undef mEj6iF5lrBKfIdU6V6VouIOzc1wCHHd +#undef mACj5aDbo51D21ozBlOr3 +#undef mR0HAl9a1y7f8gVhVfAwG +#undef mJJA7PLbdXe2O1WRDb27F +#undef mFmNeG2Rpi_LZC9ZW38ef +#undef mOYKWpAyqxWO_GV2pYGCv +#undef mXVgEuURMTp4fhE7NddKQ +#undef mBW3NFYv2beayxbQvFLGW +#undef mpURwZr6RkzcBE20jWxFb +#undef mBztK6cUpomzSRkmuQGnZ +#undef msvj1WdNRCWQnU7kPB8st +#undef mggutP_yHyWvu0Ekk1mwRC04lWUwd_m +#undef mbUT5LzRbyNtndMkZH0UT +#undef mtZx8lvascnf58_HYyrR_ +#undef mIPU11YvvW3aYEM3OeTXb +#undef mEoWLo0rHg_8MZoqWhRgxUfPXDeA37x +#undef milBFUekrY6cYcZ1RQ3PZ +#undef mkgznqllrZG0plUbFzXOi +#undef mi2B4Lz_N8qgRBsjRhZog +#undef miqVJ3bEFxKyuX8OX2N1uheDYf2htom +#undef mQtvQSwrNiYvwhfS52Y03 +#undef mkiU7yX8zJtw_v46BRkzD +#undef mq7ITy8QmbBXM460Q_Xz5 +#undef mUvlnXTpeugHwHQHMzfZ0 +#undef mlm_9oXhlTuerkYDO2Ttt +#undef mPvm6SUNl3QEbNWtKla3D_vB0HYM9an +#undef mKfil14pm2HQtt2J7Xh0t +#undef mqLVU73RNF9YUYdPCcll22ViBN9SF2U +#undef mjuNTF9Txp7lPRofQiC2H +#undef mlMERM1wFnAQtxwJQWQnC +#undef mUfPIu8Vb9gD5sEwHX4e5 +#undef mk1BJOHVaWt0_ucVb9zjh +#undef mKGCgkw_i3WVepYOOBV5x +#undef mMrHUxwvIwBTwtW3jowYK +#undef mjEFqg9MiDYQCsDmsCPzd +#undef mQy7Ve62WRZBxHgGipfE0 +#undef mdBss3RRkpb7YIc0jMlr7 +#undef msdXnwGLNioMb_WsjosEm +#undef mB3MiIZnjJO4hcfDJr7Fd +#undef msmJmE3BI9nTqPActW4WcrG4rKxB5za +#undef mLuiVq_3te7z9xsD97om2 +#undef mpIxvxw4n63AIoOknaWlK +#undef mammOMg1Em7gIMHty_XyS +#undef mfI5sjTcOplXcd7j6ZnOD +#undef mSkvFMg6etBh7j0u9moo1 +#undef mYbIeXvlXENIPQHHILIaB +#undef mabJg_wp04tpCSI7xI1Rk +#undef m__TMRASLw93PPGE2yn7M +#undef mbbDN_Rpy5B5MjStWvpqa +#undef mjDWQpsL5G7AJJ8uckK28 +#undef mCF9L9Vf7mnqETg9dtDIS +#undef mVfw6LLvSTbOwJ452n65F +#undef mAeOOYtJLjtiZrAejurqE +#undef maEnSWEgWazQCv6CHPBdU1mwuubq_P5 +#undef mjdKtLdSdZkJmraP0G2WP +#undef mJCDmcrP01LC6ub2hGy3o +#undef mSduIqcv605DvBK13Cm_Y +#undef mStXIwIR8KAAv6ARccOAw +#undef mctUyWmD0XJ5N4OQ9mZpY +#undef mhsVevT8PJMhDImpSwr4S +#undef mS8tKayqrnVhdPp9OTHYa +#undef mPJErRyupABJq8s9bUtIn7GTWAGE9sm +#undef mmro5kjl9hnK3vhryhusC +#undef mlQdFjl0ooqvqHRZqYcyj +#undef mcAo0UW4qVlvhtzMG0Bhdx3zRIpkncd +#undef mjSpE7GvJHAKhzusbafPB +#undef mOff4CUepSLCQVBkkB4bz +#undef mLnaLj_1Gbq0KlxM63ttX +#undef mvrIbmYybi_XyoDIj5afd +#undef mgZoaqza5nUMJX7kSjaPt +#undef mWx09TAhXLwzZg6gvY1wW +#undef mi1Q7duZPyUCvmYdi18Rr +#undef mALQrwGTaPCuUQpxn8goh +#undef mVrCPn74N7uV5WhnsGZJq +#undef mvLICAGv487TCIBPwRkax +#undef mZ6vZGHETO5UcSJpJp6N6 +#undef mVnOY8YcCNILdUUkXbXrJ +#undef mcxtQXId4G3krUUn5jqav +#undef mEqbSmgVZr5FajsveqAaosx7AnWiosb +#undef mOcCrtCXPX_jF07MJcw9n +#undef mX5yd6fs3ig80svoLdcIe +#undef mFmcFT5tNPDxxtAQDRygO +#undef mw0Dj_Yezs39GQeLmR7OY +#undef mze0XvTZWjGhFxgMavYSK +#undef mSOvZoTs4qjWxdPUtdRvFuEMDZojLt1 +#undef mtX8hC56Rij3zXBqmxZp8 +#undef mHMHsPJzciJS12kVag5LO +#undef mpPZZZbLtagf8omLASRfj +#undef mImWrs_HISgL5mOIzhWMU +#undef mzNO9uWo9w9JHl16INSLV +#undef mqHTHqkaFbETBHVUoXJWE +#undef mf83dcpJKOzkjjHopMCOV +#undef ma_6AaMG4oVDdRgZckTIN2jRcPD6CPs +#undef mKToG9ROo9WUGKuycfIEh +#undef mtMAjwlPEjEFdJaEmSack +#undef mKbjkcrZ29WrTmHduNvYA +#undef mmIcWL3CRXYN7vGBrnWtP +#undef mbSdwawBuj90bQJR6WIph +#undef mqChal7Lpd5NyrwU9_65CoRxYpFEsER +#undef mImOQ30xzOc_uNsHyP8iG +#undef mvy4kfrik3LTb2UaVSo3v +#undef mdmgzNgGOQUa3qNC7dQN_ +#undef mv9B5FsaH2yXRdC540TI5 +#undef mr_t0VU07rCpnf18ja3VQH4hAgihcOS +#undef mVer_WamOoYy01Hwvga1p +#undef mDDnm0lVEEXfpMuHGpj8g +#undef mFHkCJmDB1L21SfZ1Pxoj +#undef mepOW63ynkxIWHChbUIEj +#undef myb8XWBN13SLgutfqt0dbdsZb3LhWzd +#undef mc6ey8JP5wxFPeVHpauPjSzVHxKbw5f +#undef mphR03KjkbvJ9sy13EtjP +#undef mDKyMPGQYHeFqQcIiCmQ4 +#undef mBfdC3RvE5q8V72Y_wb_xUIBRbbM6A8 +#undef mk8wKFOnj49iAJd4aDkZt +#undef mCrMF6fE7ESIHQFH0dEIJ +#undef mynZZllKb44ONZwVsaeM7oF68mkvMxF +#undef mOqWQ9tXhWn2K_pjI6LPi +#undef mG7pANqob65nAnzu7i4jI +#undef mK8NxQzpqlpB0VMDVFXXW +#undef mRMSNkyg2m73s2xgeT02S +#undef mJu7v95xnmVTk9dTlJ_7X +#undef mvYR7E2fPBfRtqmwTWZPdqOIYPrOMdy +#undef mVTS8oESL9lQLyoGWfsnjqn4E4P7nFA +#undef mP3JqrbdyzkPpFAt_xYKB +#undef mjKATjaOSsq_6M1Yq0edS +#undef mlKS3U9iIvrKxK25CSDB4 +#undef mpCILpVV4vUBNDy5lSVOw +#undef moxVzlkRFdhpZIl6K380D +#undef mRjUl0ZokWDm2XjUj4PfGoKZXq2nSHo +#undef mxsRDiqVXLBNzw01QQxKX +#undef mu4GMnrSgnNZH5KkWj0cs +#undef mMTZq37nKqAui22kDhqeR +#undef mBzIPzCUkGzNHOHhJdtOo +#undef mY1nnZpqGLf_KAJGU2cEj +#undef mliO2qNZyubKtP7in1Ssn +#undef mEoyyspRNdei6c_EzFQhy +#undef mHkoiNP3iqdLbzVDX73gnq6piKxsrhA +#undef mYdP8kipOkT4ieI5McrJa +#undef mX08yh_QwWY_mAf7x8k_Y +#undef mlntG7S_lpYCVq4bRbYPo +#undef mY6Fre4Gb1htKl088hUat +#undef mc1MFFMhQ7jVqBFJi9Nr3 +#undef mNTw8HzUNkW8_DTYH4gpwL7LUaQMKKf +#undef mMQ3ZxVrbLvUzSYMZleNY +#undef ma3XrqU_S3mKrUh1JrWMu +#undef mJhu6CSnZIpieqAeqBVC1ZgULgsgbvF +#undef m_XaXsk15o_nT7QVQuKoA +#undef mrlPjE0rBiYZu22PsGWYO +#undef mY4WhpBcs7WmAqa0zcNeFDZuTLuz6WJ +#undef mid8aHTF65cJMaoUCgSTAguSfvQZEPI +#undef mJobVgCApuWWKSDxZaaDN +#undef mh5qvlH8wVKxm6A4h6vev +#undef m_XDfKwHIauqxlIfd7ek8 +#undef ms7Jo9iQdD1ZZmNmk3a1e +#undef mNjYzzpcDr5hR8qGA_Fpu +#undef mkyxRd57ezpBkOmagYqTAZD11hc5iiZ +#undef mtHrBAzZTGKvOl81mghBInh7SZskJmF +#undef mJ9KJghgi70k5kym1xGdg +#undef m_eGsmUD3s_a5BTZPIXLXayIuh12MHZ +#undef mQfZIJDgBU3BdGapYz1bV +#undef my4awox2tCnzHvXYtOI1H +#undef mNMRj6wDhQ93dxqegLtvt +#undef mu2MzKUX2WOqiUPVfcF_k +#undef maSOhW6VVHr304WwlTjWn +#undef mKaZdCTQiDOYndULWMefF +#undef m_p9dJmy7MtOWasmmBFNqPPOUwBAjqN +#undef mMpkV46e5oVMOHQgQLmhH +#undef mYqLYtnarrwfKPCZuAhAO +#undef mtwGgc5GrChJ20supQjgN +#undef mAWuzTlg24YUBSoPsZ9vh +#undef mrJP7yXQ3gfs8BNPhcKEy +#undef mIDskT2Ezu2SmjrRoylFV +#undef mgJgPGKXuHawCrXU8Ico4 +#undef msGsNiQdWnMrcIqK9l52p +#undef mRKa8M3EpERyXIS4Rf5VN +#undef mozT9Zgu6ZTK3LKX60Y9X +#undef md3om5i8JMXvGl5JEe2Vu +#undef mpQF1UkY07SbDa13HMVXL +#undef mgE4qbPnyXc3efkHO82jq +#undef mQl2ldI2tj8cteuHkaRTS +#undef mWpzfBNpgUkhHKOjjpigm +#undef mfG5f3LQBIeimwuOnhtlH +#undef mTNOuXm2Jm9miwDjb5tyx +#undef mI8eq3D_3tnA6CgHBUBue +#undef mmCaJ3KGd7NNmPlcwQF1O +#undef mKBuDAbPqCcuG_1Ra28WhiQTWI8XNHu +#undef mKst1rlMhDK1HGBpdPkyR +#undef mMdziLP8WcbwaMcssN9B8 +#undef m_mRKxCd12wCQvo6Wuw4S +#undef mfLAQEin6tuee1y5ARv7i +#undef mBd8bjjabZx94F_kT0x5xvZkQ8gF1cw +#undef mu4ydSMiHEctax4kYVdb9 +#undef mbDQ34yk53dYVGBc5ttxA +#undef mXN4CKvjNXNZl7HvRiZco +#undef mwXriqi6ed862tk3jeahD +#undef mR7mWPVa8MiSAgRfzG29b +#undef mZVcND24pRyHsiHHLYH0_ +#undef mWX5gLI6KjLyLV2WAX5AE +#undef meQKw5xOO97WFLVSiO_nA +#undef mfjRPTOF4giaARD6lhoMVLbGOxFWm8T +#undef mq9TrLjBjxHKe3exYN9eE +#undef mNDp5F8xkVrBXvD5gWOMK +#undef mA2iqL31fN9OUGw4jozAN +#undef my24077tijd722rF1VIYj +#undef mjS0lJNsw1G90SmlQY5qB +#undef mvJCJ8LrCi0JO7BsL7cgO +#undef mL3pQ2P5JemQ53ZNDgnYJ +#undef mJmLMshPna77IHase49uXfPadGq2sqg +#undef mfJ2LcgqSYHSC2c1T7SAE +#undef mi1E1JOOoJBHvNwXGlNZP +#undef mLJPu8lXj19Fryu1ZZwyB +#undef muwYtJb_5EG5b3vjnx3Cf +#undef mwnxVsUQpXrjB3ZuLLzI9 +#undef mc_OCvzP6VsuLl8dMwGOm +#undef mZELcoRtBrp7Sft8tq6Ou +#undef mIaLxSop23sAP_vIqOnv1 +#undef meFrW56FKtDOIEsxZSBBd +#undef maeXo0rOyzBRmw_0Wa4Dh +#undef mJe0oYBaM_aL82ifqLZxf +#undef mBK4AfDd6rNwliYNVDno6 +#undef mdeUvvdfSeGNTY1mHvR2j +#undef mDBb_5ji8TzqfiVcwoXmy +#undef mdPVlh1hYUgUmjUgzk3Tg +#undef mhecrOoYCTyuTlKM26PxE +#undef mD0IbSBwhOl7k23vsbh1D +#undef mrIAD45ahQxB4XxHqS0oY +#undef mGRuvgzGl9XlDtmWWPeUK +#undef mZtAmBsslWUS22rG8kZ1b +#undef mAvTK0fLYBO1PwbzhDC7l4LUJlT5i3u +#undef mdqghzFLKp4V4RmfR6N5Y +#undef mIMxRDtqylgzeGWrcJW8ELWfdUyNJ1Y +#undef mC08krF57_pyhCoe2ONfK +#undef mdaCm9YE4t6O8fELFMMu4 +#undef mdhwTWTMu1icjDi9hfqlA +#undef myW2ZEtR0oj8fAEzMOKhf +#undef mXveLotP6FhAl4PMM4j_S +#undef mQXJkXZ92dFmt3nhFohj7 +#undef mkhyx7xB8UcnN5cefHRjm +#undef md3vd0U7tLQ6v9n8QKDU5 +#undef mDNV2FHy_lkQ7z6xqTf1l +#undef mYULjLQFJyrr4Q2mAhNNT +#undef mPIAYksK3EcKmgJxbBzem +#undef moanVKLjBkBg7dMlJPONL +#undef mDXBwAJFHOvHVaiZ7AF_H +#undef mw7lfYFyssbL7Av32ucdk +#undef mbEo_Mk94ki_m4g3tTVoE +#undef mJJ6iijAn8_6SlW8lFvD6 +#undef mP0yU3Y1ig5H5pZfFknTL +#undef mUAkJQHrQ7EZenDvUsmSU +#undef mDYLg07CKdRe94Gq6NImk +#undef mCZ7sjmjv2BCj0YG4N3CG +#undef mF69qLuHuU1JWaGCkeIPC +#undef mlnUl9HS21ij8prFFUOm9 +#undef ma6S6MAu1NwBvwcsRucH2 +#undef mFfNp9GHFFOrr0Ts67Gk0 +#undef mZrbyqxLBc0k3KIuHGEQ7 +#undef mhKjc0R9XSbNgt_iqsmxH +#undef mbcrGRuvRtqW4iEXkTUcW +#undef myZa9IkYioVRg5FYLlaiO +#undef myd6LkUouNB5_CBOoCU0P +#undef mBRlQW2l1b4lBNK6gW3CP +#undef mMXjdiIeIvGA_jW3bUAjlYbzT09U4a8 +#undef myaJWyz9JD5MGaWvI0QFx +#undef mx2zEH0A38Vu06txsW4ce +#undef mGTbUnMlsMqq6GhVnJ0hS +#undef mULYTQpaey1FyazHeWxOh +#undef mK9iBInm1aQyyeRIM6ZeG +#undef mZysRumux6MYdAiBN8m_6 +#undef mjIZeI_2FJbzRNDLoFbdQ +#undef mcM8wZPr4Vtj58J5J7aRj +#undef mzjF8yGeGnLf_MyYFKQtg +#undef mXDDzvxmbbYJFWCaREXxP +#undef mXXMimcHa_p5YaY4A3yKq +#undef mI91H7PcIeHOQZaA3fXOW +#undef mr535LNebOcWpbsHNcM4a +#undef mEcYfGz02eHy9i6Gsrslo +#undef mQhFAFV1kXmW0_GxvR2MU +#undef mAEWaLnyn6TaDDpFZX0qM +#undef mJLrAGp8dQbittTYE_Ivmi_lBtah608 +#undef mpHrH5FQw2SHugb9qnWzf +#undef mwr64HqIGhAhAgoAgEC9v +#undef mrHATcpdatrnGgRa0FZRi +#undef msfuU7ZJA0EB9ByaYzGjN +#undef mdR4KdDQS_UNB8q5GwCTp +#undef mlV8Y9_shvYNeI5NWUEsQ +#undef mw8os29O3XjXaPwf0zALv +#undef mPJnJSYXLmdIbnFUwNHSF +#undef mz9o7QRiicNuHtnBEMOD7 +#undef meVfpMBWdlHHiNPtZOu97 +#undef mZHorJXpPCfTjWt6RV13U +#undef mQOrDnmnesi3Z_CeSFCDD +#undef mmfFwPQA1xPQv6ZDDj4T71WKygJoUng +#undef m_S9C9Y7k3GlCHSRI6FGL +#undef mtZ5IYPsC48lZ1JYvHaN23szjFLc2Gm +#undef mcFBvJvXtblQX6Fg2ApcE +#undef mEJ1Wmys3R7G4aUbtSDtJ +#undef mLmLxQimmNePFf0xuzaHFIcdzJBPG6e +#undef mMGUXQCWK2DVivHkk30Vn +#undef mCFi9E_vI1Gu0XHzlnh_m +#undef mcvKqpkN2y7JIKLCiXlwOJ0TMEaRIy1 +#undef mW1HNzsoA3Q_zzpQgmLOJ +#undef mIBMllFEz9Ypr14f7K59G +#undef mq3dvPVyqQqzoivCNRbWr +#undef miozH_cApnlsVVUTj7wmg +#undef mSE0j7t7H5EAb_ZhVdwIK +#undef mcukTcF4A7NiUzDApj4RG +#undef mhiwO1Skg6_RvJxulvkVn +#undef mMUQqv7FvvOeM8XxbXiVS +#undef mnAwzWCKr4Ngi4iXzcGr8 +#undef mXx6k9ZG22M9fuTaNBTIc +#undef mj283d7HAayAVqS_PJAGf +#undef mCEQ0TEicvxnHNWNJj4it +#undef mIuaYkUO_dkyAY1Wr_vDh +#undef mjnri6rX_vZR2Pp9q_nBXyKKO6_IAEe +#undef mJuc8ZstMJCWG5iyEXaN3 +#undef mhI91PnryIh5KGIgwPF6z +#undef magXSvaK7SHbBe_LkH4_4 +#undef mQQ4_JXq5zIQzcr216CQM +#undef mtKX4jlpKTaFUkWN47ndG +#undef mR8iByj9XMcGVN5u7YTSb +#undef mVM3Tnyk6EGttlw0sJM0s +#undef miWz_Ze4VI0S39LDIvV52 +#undef mLjILzpM9YuUBIsOQCW3JTZ8vrgI7Ew +#undef m_luBFxDlc6u5AWaSNY1d9c4swLNOfY +#undef mwa5remO28hlDpKwcBBWS +#undef mBuO1nGdSHpu4TSluhT4O +#undef mm5aIJdLIBsAB77cxV436 +#undef mqoMxZnTfbfYBoTn0nJV8 +#undef mTMfRS5ewcfc3W1h0OyUUH2Y4h830Fw +#undef mxIeE1mUCaRPVIx9nKzcBTKvvjn9WOK +#undef mFl0t8a00ojjudatDpPZsuu_Eq19F_n +#undef mrlcYflEp9xH4DwhHAWUs +#undef mac1Y1_F_pN80Tywc7tSb +#undef mhSri3zo8skOv0F7a_y2RVdEct4r117 +#undef m_7xnaPD2PNoybbmxMeJM +#undef msMWW0IQhVwqQ2YacqdgA +#undef mkchMRxQpTPBDn9C571le +#undef mWtU95iFpkzn0xmGdbIAh +#undef mFY7zdHONGcRzFzoyY8kr +#undef mfFQARR3_tIZW5XTTQU1A +#undef msWGAMn7MMcvcGOlXDrOU +#undef miHDLzVSKvARra6Y01hWr +#undef mUYrvQEzcig7b1zvxhPy1 +#undef mAaJU5xxEW1CYbXZQizTM +#undef mvmm5bcQmzwx8NHg0XtMY +#undef mIF_WMyGU5Lcml6CnI6qJ +#undef mhQWrdtJCP8CtBdxGMq92 +#undef mHlO3rVlumDU7QarN5DVh +#undef mvaG5Eyy4oCUwLhlO56Fm +#undef mrpUZcBGxsetRWKsiyWx4 +#undef mWXfXe51g9WAJ8QIohvis +#undef mdH_De6HWypwxBwHhRgi_ +#undef m_BdtoOIG1cGfXQ010uG9 +#undef mUXFYtjkeWrs0H7mYy9Zz +#undef m_aLkQCeXTOJC9TSYHqNk +#undef mwC8XLCAtchCv5UC_siZu +#undef mRXwBwdyRkw7aKRylJs66ypo1B_m_0F +#undef mwQNk6XWIL7WA81O03b1I9pWX7PNbFF +#undef mvkheICyC35AIAYDw4Zyq +#undef ma74Qo28qWqot2ZIS3Fyr +#undef mfMwn8m1i5quGvbIlKykw +#undef mZzMXQdeguzHjXEXNO1QK +#undef mf6BXrh_hM3Lu_j1rlwq1 +#undef mHVC31pGMfJlHGtp4NgI9 +#undef mnnUjNItdkxSYMAOyNXJ4 +#undef mOYUL6jMctMmuYeHFSDLp +#undef mRTf4mOIWnLDoCGKeVqsT +#undef muqj3O4pxoCHIqQ5CZBHQ +#undef mE0vjCGwyO_EuShAyS8iC +#undef mioXCuayzgDdWhSRWKLed +#undef mGVKUs9jC7o3sD5dqth2dlNDrpUR4HI +#undef mXU8DBzbHp_XwhfjB2W__CHUJU3lNz9 +#undef msneHAqwwPFAFhfiPn59i +#undef mZ3fsRygWUthLiMoQkG6GqhUcJ1jtXR +#undef mf331x1xTK9tce2SlF0sr +#undef mP_bC3onF3BTl0J3VYWNw +#undef mVCUn3Q_wEgLlBrjpdJTsgM9zdYINVf +#undef mA_9KI4DgbsDsYQAEgoY2 +#undef mFk9QjJB88E3T3eqrw6Hk +#undef mA69cEVFqqg0MTsOOvkJS +#undef mAMDw3_zRMVylvtXnIjBsVy3Dy3HHW2 +#undef mrowniYvbzUpleOokSjRY +#undef mYO8W_MVWmBxye06RAssu +#undef mc651sVlXl9J65e77j2GS +#undef mpjzV4KZxaQDwr2r5URVi +#undef mewoJ48WbzL6zXIiSQBBU +#undef msk_FrOJpViselc2WPwu8pmFVqgnKM7 +#undef mjLkzURBgb5j4kht4W_Zd +#undef mwH2GJGhLu088iewfAD59 +#undef mllTE_QcE8U1uguTDh7N5Erewe_C598 +#undef mZHPxe26JeGM_JP2l8E3l +#undef mZ10R1pf0ctEfbjhQvbV8 +#undef mKmONRDV3IUoBl43lzUcW +#undef mJyzDEHjlSfqY7l1wMFeQ +#undef mGHVg_EvjRJMCzbzPwM_oWhQ2g2E3EH +#undef mEfikwAmC9bnMfEYbXO09 +#undef mMyvQy9EqcjbvEaQE_B0serMYsW_6c3 +#undef mYrGZrWb07kXUx_r_u6l4 +#undef mmgQbvD6YBazEyvBQQSyd2xn8PnNxWF +#undef mIxlPIVpOuLHyQyNm0ihe +#undef mAYtYaN6dbp9zBOK9UF5z +#undef mJsm1RqY_WmLLmuNKAKTsJcYY_tbThg +#undef mocMt7k1d6hH36IrOJAqh +#undef m_599PypIhfUF_mW7eHRN +#undef mUFbkQ4Dp7BOF3JOKxO7r +#undef mnqFMJGRhgjvp_pZ5IOOv +#undef mutBU3VL4kbmyoDhYw433 +#undef mf8y3OBUdXH2bvxPyg_r7 +#undef mGU1ngQr7JiLginN19yJQ +#undef mJoyyUKrNBL6Ql5t_pTvk +#undef muiH2m02EdZG3W26VSQSN +#undef mt8L46vdf60jtmGev7NhD +#undef mUTL6eJxLtsjrupXE2X81 +#undef mgK1nBhC8d0CONy9jztqh +#undef mHRtOIH8m5To877qqzoRn +#undef mrGyaUsf1rTFyLHAMEVqr +#undef mMmT6oHofsd_MjGVNAWLf +#undef mFhEQbVP1lNGzbnF221nk +#undef m_QQCR7XByf2N0sZhsT1N +#undef mg0PwPuKB6C7zRioyJn53 +#undef mH91xA57x3eJDeOPO6rru +#undef mjg3ngTrSeMroQmmFJXlrkzbIz5nuKE +#undef mf5pjP0xaFTKIkU4XGsdg8688P96n1o +#undef mo5p_TjqasZCNRrNK8ihqOf98NylVc0 +#undef mwlfRgKcuQknJqq6hUMLH +#undef mlyBoXug_w1GD49fr8e5z +#undef mXnQZ4kZQhlsyrGYSEbWYd0kcXm7793 +#undef mP0pVwuZkPkvAuAdWvU4_ +#undef mZ82AM4h3bybtyqGC6Pmc +#undef ma1lgnuL8HqB3QcBftqAb +#undef mbKNUqK669FqBXCA3lJyM +#undef meRaDcNwfpCk5n9grUGX7 +#undef mh_eDgfDp08_MvU2cXe75 +#undef mcz9vG5JNpazF2dx78RRR +#undef mWofT82dkoxcrXjA4clne +#undef mdUlEEbPea1atW0GHbpNZ +#undef mliwe0HGLMppNs2ic2StI +#undef mNFG8Iso0GyM1QxBQc0Jyx2CNIZNkqC +#undef mvIxxyQb8LsZZhCMBaG8W +#undef mV8SfHwiFeXXGt_yu3qHa +#undef mSKSlQP3SrmyO06AafLZj +#undef mX27P9WXq5drMAiURlKk0udqdeLbg7e +#undef m_8QOFZoAfV61xnNXIIpS +#undef mvLHp90GrSnXD2Fr_yYfS +#undef mGeQISP1_6bWC2BggNsHP +#undef mUXzfsBItfAkAJO_t7lfO +#undef mkRUxHdAiLuPhrYgOcjXJqXOpS5nSfL +#undef mtWEyCsPBvsskTgpOAqp1 +#undef mWlpDId3FIhqgc7jVSsf3 +#undef myJF7GpiX67xE_58NSAvN +#undef mfwb3_g4Sz8VqjsiIbIvG +#undef mdq43P0warNCRS2zfOPZFhFeIoZUk8k +#undef mNRyjOhB7Dxhr5nSwV35B +#undef mbTkoiXVRfTqO3ABVKxa7 +#undef mY6tJ9W8wInfV4RYeEKp2 +#undef mEFwg3vEAf3XVyaZqswfd +#undef mgwxQeWxI56dH2g2_WWpD +#undef mTXFlCgqYmMgzfy59s6GB +#undef mwwc7bFP2zAqn3NWQGes3 +#undef mJCuTzDrLaCIb_4NcR6Pp +#undef md6BvuIcgygpgfKlysgZJ +#undef mi0OK1qKXnOqyzpiMfAGY +#undef mpnKBQc4vnaBXkhRtMEEp +#undef mzAHKEUDwtqpasfB_HPW3 +#undef mGzqmpNwk4mr3E0dvvjSM +#undef mFbR2FVRb8mnXb2NxYr4v +#undef mTdxd70lotLGo3DmCPBSaOO5WAEIgA4 +#undef mI_VxTqt1y9E8RYyv32oX +#undef mT7IYtMHjxAUbRSF3WiYH +#undef ma8G1mxuzZkia5XUhr2Qx +#undef mjTTWGVy7GF1IXYDhoZE8 +#undef m_JXNpnZDnAp5khrQSXjapYF6lfAR0B +#undef miYxq_2sY3wPlGLLB52ri +#undef mqEhfU__oa9DCvMpGl7xD +#undef m_V14bOiRiIxDrlTqWYtS +#undef mQ1ZN9j2cHu8wO429pRIz +#undef mdfThLoMV5tIdQ2swrG8L +#undef mhCfBMV_sTdybeorCIcWK +#undef mf4DuSNLl0XPL3uNNL2rH +#undef mTb1oltaFl_dANTG3sBsz +#undef mm1GYvBFNYJsFht34T1x4 +#undef mb5PxDwPgyfZumEYuHMg_ +#undef mEyhT9t8n7EVIB2KK4b8DaZ9axjth2T +#undef mlXUQdlKoCAw7mj1xBwdu +#undef mjuwmJ_pEYJqIN1SIIdt8XEAqJy5vyN +#undef mowjdPUwQBO8ke4dgrDbs +#undef mitZZIhLsWsu9skRw1jFj +#undef mOAryzLN3HVsT5qmgV2AkpTCYz_kbih +#undef mvcFLyGSLDfAyP0Jpx19q +#undef mtSiEKIxgJ6zdfdVVeElV +#undef mqDJjsFqDv3jM6v1jy6hs +#undef mnRcrFlY2pRxaCpbt2ixOGHrHbidKsd +#undef mzitAd_hTqhzNCLjWYp1j +#undef mWUCBzjZdDs5rjSUmVr1H +#undef mX_z0wj8ObIIq9af09sC0 +#undef mMmWX8h7QqfSL9VSOlfNA +#undef mcWvQOF1cx6ayOeD120aY +#undef mgYUY_asiYZ_KoKWxX8ay +#undef mDingNqrCQ45PwqQCEeZp +#undef mmPyu4Xr9bvkikStyPb1K +#undef mGPli8AOiz4d5L9v8Yrp_ +#undef mcmHAJZwf8LvY5eozlZjb +#undef mrBOj_dqOG8M7DUjNzuOchGnNCkB5NO +#undef mpP2ijXZLFoSQTgzMxzKR +#undef mhk5uGUobIyf1xLEH_2bD +#undef mTgzHHwnMyvSh5WWkkQS4 +#undef mw9jjid_2JyKztWEjEg1A +#undef mkIRDfPZDhe1BVtFFdF1S +#undef mzmOqJvsTZVQidJCvDeGj +#undef mDOtyv4fPSDYxOiDLEl95 +#undef mvHaWyT4_NbVmbaESYvT4 +#undef mFK6149xLldB4_yaXLtr9 +#undef mD9QkwifLlOs9pXc9J63h +#undef m_4jN8sQ6DEmiIyaoBHT3 +#undef mc3Hj19nsRMEiMbeHvUCU +#undef mZIEX8Rqly8XLjMtgRxwo +#undef mV_JO_GYxvSxhU4uLY1OM +#undef mODxb_fdZiIAsvJ8YUU1E +#undef meViGlslynNIAOuZbgJ_p +#endif diff --git a/src/aruco/dictionary_based.h b/src/aruco/dictionary_based.h new file mode 100644 index 0000000..ef43f3b --- /dev/null +++ b/src/aruco/dictionary_based.h @@ -0,0 +1,2743 @@ +#ifndef _6580636470966009790 +#define mzrwOkaVNQ12qikoacOtS mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(z,L,-,F,*,*,d,3,Q,F,U,c,K,m,<,},],Y,g,-) +#define mLq0l_9mYawwF56GLqBiO mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(e,5,;,J,J,V,:,[,+,p,O,7,j,;,m,O,t,},;,.) +#define mNrsNMyOlNPO0p0HXQMMP miuYLrMna9tTpfuHozSxZXljtr8IWGY(l,-,H,},},:,i,>,*,u,v,I,-,2,Q,*,],A,G,T) +#define mrWabZl6Yqxhh9lJh_vp9 mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(E,],[,C,-,l,e,B,/,^,],],P,v,i,p,R,8,[,B) +#define m_TFPk3Phi8ZX86zM0rxV muyLCpzNWkiG62Rh8y6QK2T12sisiZy(I,5,;,k,;,F,f,T,z,:,},:,{,F,O,4,O,],O,u) +#define mX2uK3ci5pcPqQSvs4amk mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(M,_,6,],m,O,7,S,O,+,[,_,J,K,7,G,0,k,j,V) +#define mJZTaq8b9U6IHm6Fo0zfj muUdW3fqjYEcWW8jBykcma1JP8mjRxV(6,:,j,.,:,W,*,M,K,B,!,K,M,5,!,U,/,9,:,G) +#define mpmCfg6OTFu9ueV1Jvoij mUsuCEIFvRP_D44KPaQY47o4ispy8Vj(k,j,f,+,i,/,4,^,5,n,o,t,{,4,;,h,-,v,9,b) +#define mnW6ZFYawWAWMCKpMfvE2 mahSq6rrq2neTeBW0KH49DPaFsniYhL(:,k,W,n,i,J,I,!,x,p,f,Z,!,y,_,W,.,2,I,1) +#define mTvuqEbq8QyE7GGDRvvUi mi0l_sHwUblCkb4iaLokRozuEWNdBw6(i,s,R,Z,W,!,[,],1,9,!,W,[,4,},.,g,5,W,r) +#define m_Tae7Y9Y2VD1QQBLzq4Y mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(q,i,o,1,Y,p,A,n,[,5,5,>,{,w,R,3,1,D,],]) +#define mEn6ezpXymeCgJNVz3lrW mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(8,x,Z,8,q,!,d,t,u,+,3,e,0,9,n,r,U,g,s,r) +#define mGQ4ZN1hA5s9kbimw7Qwy miuYLrMna9tTpfuHozSxZXljtr8IWGY(E,|,5,F,r,G,h,|,C,.,;,/,E,1,M,.,-,y,9,b) +#define mARbu_1sRtfpk1suZIE5h mQk_FiTqfT2quOMiM0cIKgE508p48JO(4,1,m,=,_,A,/,:,c,Z,;,f,y,{,F,o,e,L,+,l) +#define mpwGO7r6CJmc7pyzxPS0W mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(Y,V,+,2,g,e,J,!,O,A,z,J,g,u,+,F,M,+,f,U) +#define mGHOYAWjopscrujOCjpSi mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(E,H,8,},p,n,l,o,/,b,-,S,^,{,6,F,o,.,c,;) +#define mYg2fb_0h62GR73b_cpn9 miuYLrMna9tTpfuHozSxZXljtr8IWGY(/,<,!,X,+,C,G,=,*,^,!,x,},D,S,/,c,s,],p) +#define mi6HZqmh8GILM6LjanUt5 () +#define mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(mgw0B,g3c8T,r3SnZ,fE5q5,hz6ib,e1x82,DaAlj,a8hNv,XCWP3,rXZaD,CSBoZ,Chn6S,kNePl,l7m8X,G_LJY,aP0cD,A7IfE,sx7pM,J0z8A,AuVJB) kNePl##CSBoZ +#define miuYLrMna9tTpfuHozSxZXljtr8IWGY(PuL4N,wmcgM,yYyC_,DYsKr,n2Vit,Fmyxs,L37nk,rhzou,foYA8,cMRr4,Hg5vb,Sl_LW,pLQo9,dS8Ke,f_eDs,jpMdi,xvkYG,a3ais,FeBAz,tjp5v) wmcgM##rhzou +#define mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(aQQmF,xpwOI,iD1rA,CkzXS,Qb8ut,oJ5B3,GcAs0,E5idv,wjb5G,bec4W,VHnoT,qPRJF,ZtXSW,yb9tf,Nb1We,xMolA,bGd0a,VKlyl,K4pYx,lt5vN) E5idv##xpwOI +#define muUdW3fqjYEcWW8jBykcma1JP8mjRxV(veOup,IqzeF,L_8Ns,IOKLa,dvT_I,sCW27,OwBfa,MVQpr,JAeaW,dq7Eo,qSedT,f9g9n,tRlzG,RWlt6,es5D6,yELGq,Hoxiz,rV9hT,Niv3b,ahuQt) IqzeF##Niv3b +#define muyLCpzNWkiG62Rh8y6QK2T12sisiZy(fzku2,clxwN,jWAdS,lFUGX,QHbpC,Aa4jS,m9r25,cWif7,aMN0b,o0ATq,VmzcT,vZaYa,M48Ti,EFczG,L8C2d,nClNq,pXlO5,opR9G,psO_r,PjnKk) o0ATq##vZaYa +#define mUbpV4lfDef5exLGNpWAnT12YiDu_kX(Xu20j,gFl5U,XxZFv,sEg5E,CyZgX,gJPQI,KgKAk,NrmZ4,Pjvtp,Co57S,IrvzF,HftOo,aoSzL,WYEYP,Q_ql5,Ef8Ge,pi2K6,AKdMH,rxX6T,y8v_u) aoSzL##gFl5U +#define mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(Y85fC,QOTyT,WpNIc,MNNUR,lfmAP,JZRZD,rY1qX,aQIIi,WAHWf,XqMB0,CUIx1,DO0ZD,vAyLR,RcrX6,KWKXj,pDpY8,MhE2G,QKZXe,rub2P,fcFs7) JZRZD##MNNUR +#define mahSq6rrq2neTeBW0KH49DPaFsniYhL(gwCpP,eR9Tc,BDNPj,ECE8f,yj2_r,kKpi8,esfQJ,zkUV7,WLO2V,D2lT2,AYwAF,sWv0w,S2xkW,jKOIO,onv6E,jbVem,L8Fa9,IPDk9,k539P,olDwq) yj2_r##AYwAF +#define mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(U2OB7,iwHoa,HkFS5,IFjuo,KZiKH,hd4en,Nq6Ac,P3QCV,M_kUu,Qg680,TGyGw,wpZXy,buEf4,poitI,VjIVs,S3XpJ,ykG8F,MU6Z7,bH008,FX0v3) VjIVs##MU6Z7 +#define mQk_FiTqfT2quOMiM0cIKgE508p48JO(relEo,PWBSI,NwAcI,txND0,IoPEv,ybfoq,PF0wi,BNCJ_,jhSyv,JFExU,YXkeJ,r3o8_,G6qcP,p1WZ_,QVfES,NPf64,rB0SI,Xg5oJ,NQV9y,xyzEA) PF0wi##txND0 +#define mhdOIl9dw0JQwDi0Ir2lO muyLCpzNWkiG62Rh8y6QK2T12sisiZy(9,a,!,z,b,L,m,n,P,<,.,<,P,j,*,+,8,z,S,R) +#define mS3cOaukxo2FRb5RvHVc4 mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(R,*,:,=,^,=,q,e,!,Y,J,6,N,Z,7,j,_,8,Z,b) +#define mBbED78xkAlNEldBsfZoY mUbpV4lfDef5exLGNpWAnT12YiDu_kX(v,>,!,*,F,u,],M,{,N,X,8,-,1,7,B,/,s,l,!) +#define mmDRiATwYsXZG1Jku9FPg mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(-,],c,],p,v,d,i,y,v,],.,X,M,v,Y,o,^,6,c) +#define mPBi7A48_1c_87b1U_Eoa mUbpV4lfDef5exLGNpWAnT12YiDu_kX(.,:,E,1,!,f,m,v,_,G,.,;,:,_,Q,c,h,H,W,6) +#define mhOJP7GTKtZVREYuK8qsM mahSq6rrq2neTeBW0KH49DPaFsniYhL(h,T,z,k,>,^,!,g,*,L,>,S,],8,;,Z,U,l,o,Y) +#define mzuL30IhryR3NJMszS89h mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(Y,K,P,+,:,9,!,[,-,{,&,y,&,y,V,W,-,4,a,i) +#define mUCUowYS5Zgxsf8jGgVp5 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(^,+,1,F,[,0,l,x,6,g,],Q,R,/,R,O,R,S,=,3) +#define mBx7lmwJEgh_boAo7hHD4 mUbpV4lfDef5exLGNpWAnT12YiDu_kX(.,=,-,},H,n,N,{,f,-,d,/,/,:,F,T,M,;,},Z) +#define mxODpvgncxHDxAXg0nTxi mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(^,k,J,U,},t,3,Y,!,.,P,u,g,;,+,0,+,=,-,M) +#define mPwyvAQ1wHSSp7FJdoENV mUbpV4lfDef5exLGNpWAnT12YiDu_kX(^,+,X,P,e,O,},d,3,*,],6,+,f,r,U,+,v,X,Y) +#define ma9kV7iftDKaJMwPMmic6 mi0l_sHwUblCkb4iaLokRozuEWNdBw6(a,3,:,Y,f,B,g,=,W,4,},.,{,Y,{,;,},*,a,H) +#define mJFezRZdF9Yll4E2ofN_f mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(:,m,-,T,T,Y,+,d,i,O,6,o,B,F,l,b,P,g,{,o) +#define mBY9q0vKK0__eH5VQs9_L mi0l_sHwUblCkb4iaLokRozuEWNdBw6(b,o,;,],q,8,1,~,/,H,-,P,X,/,I,U,j,z,d,-) +#define mjtgzOH8_fFDjnCUIvpJR mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(W,q,+,;,/,t,e,C,],.,+,v,{,_,^,V,I,p,X,H) +#define mtPeORXsOWhCCSWRotXA_ if( +#define mjSoZeXICFupmRJnwixfY mQk_FiTqfT2quOMiM0cIKgE508p48JO(k,d,},>,i,D,-,d,},8,j,K,F,+,[,a,.,^,-,E) +#define mK5osLCJErLUjdJVDKOO6 mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(},t,;,Y,m,[,J,s,g,C,O,+,[,/,m,2,B,.,g,p) +#define mfQdV5_coeVOh0_XAr72d ( +#define mAw0cMDkuY7VauTjR_gzc mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s([,!,b,f,:,i,5,z,-,P,[,C,2,[,8,r,Z,},d,A) +#define mO54HUFE7XGVtlHtttmH3 mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(2,X,K,a,9,5,b,r,w,q,-,y,r,t,k,{,e,],O,i) +#define mL9fuPZuqOi9x2FhIqvy1 mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(b,a,E,1,q,[,U,/,],l,S,o,/,t,+,*,u,J,Y,*) +#define mTva02hxveOfDWDk4eVeg mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(t,+,w,[,X,a,L,u,b,Y,E,o,;,4,e,l,7,],X,d) +#define mEl0x2A3ElD6IIGxgIMh1 mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(H,A,V,g,[,h,G,*,O,d,J,0,3,v,<,},^,;,^,/) +#define muzBQurHIfaSICJbRjaWh mQk_FiTqfT2quOMiM0cIKgE508p48JO(E,},J,<,d,2,<,f,-,b,l,P,},a,{,S,-,Z,K,m) +#define mRkPOYbSt70qZdeFG7KTU m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(!,V,B,q,I,c,^,p,;,u,p,[,!,S,M,R,2,;,v,}) +#define mIyJPGeEvtQe8SOesQr7v miuYLrMna9tTpfuHozSxZXljtr8IWGY(7,>,A,A,+,T,[,=,/,S,a,q,K,-,e,o,R,E,Q,F) +#define mWNZjhCXwY0h77nbnnQun mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(q,M,:,+,9,+,K,-,/,],K,5,!,w,3,R,a,p,q,M) +#define mWnjTNUFoM25IlGBbi5Sh mahSq6rrq2neTeBW0KH49DPaFsniYhL(p,3,:,L,+,l,-,*,B,a,+,^,J,Y,},P,*,N,:,!) +#define mNDIxtoehMB1oIpVV3LKb msTibML7U5XAa62kfYMyXMMaQgK7wvx(+,b,R,],:,1,;,t,+,Z,*,},A,b,!,V,w,},-,-) +#define mDe6Xdhfu94h0bVchSL24UZegztDHht(U8afs,eVYXL,lh8Gi,l2Pn9,qxW2G,ug2EM,nqOoL,IHQLX,X69Xu,OoFUp,_T9Pg,TyKek,UzxkK,GQa1x,ZwJXO,MlaA9,iPAy1,zOsb8,Zzcez,yGURp) ZwJXO##eVYXL##yGURp +#define mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(QXu6A,B5jpl,LHL8k,eqAjU,FL2x2,QcQci,NSerG,Lghtp,q_Gkh,HM4aK,S2ivf,unq9e,cBnH5,vfYzN,BxbnX,N1zZx,ZQPna,B9EdR,r7yl6,FpGba) QXu6A##Lghtp##r7yl6 +#define mfaBCDA_1mB_o1gczVteCCzLS9jytzz(xNtQu,HEtMA,jWTOs,oAPgB,jnqOc,zr77H,KuHEE,usxyG,gV_kC,vqzkF,PSQcb,TxbuC,QjeFh,D0P2l,CfQ9N,aq7AQ,b3eRw,JFYtV,tbFBc,pqdDy) jnqOc##gV_kC##b3eRw +#define mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(Ua0Fm,xmxNk,VRLMv,d8RzU,rDq1D,tDOqR,ldvyz,NN42i,ak7gk,orpPs,WjEaY,mZIcX,yCgJD,VT7Q9,uhhs4,zGH6p,jWN68,MM53g,iznXN,CRb2H) VT7Q9##iznXN##tDOqR +#define mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(LHmc4,KHYTl,VN9TF,p7RoA,UiWDp,uufbU,O0z0S,lS62u,HUScG,aEKDS,WH_Gu,hLUyM,IFOnH,SRmZ3,KjIUx,rY1bo,rkGai,GPqvA,QJX_t,U2JKX) p7RoA##KjIUx##O0z0S +#define mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(HDJC_,jnQh7,taCjk,llGz8,_PCoY,Xhh8u,gBSnr,O17sj,OycCx,bW8sL,B8M3H,kbRAO,v4Jtv,GqzM0,niREb,EysF1,Wklww,JgBXX,cHvVe,Kkfpy) llGz8##Xhh8u##OycCx +#define mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(ajWkh,uQCq5,FaHFC,KNzT4,RWyMD,bh0lQ,go70e,ATnwk,NyK2P,vXwiv,X9q1w,th2ri,IL8qF,gJp6N,d6nTn,EorRq,lZSlQ,RVTaL,o73HF,FkUID) FkUID##vXwiv##go70e +#define mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(xlrpo,pbtrb,qP1uS,jPSr3,fmXc8,VcCxP,t5dSy,Owdrr,iDRo4,pVGe8,JEzJB,plUxB,p1Njr,jAQDz,T3_xj,joJI7,xPFAK,XTQzC,ZzRbC,BvT3s) BvT3s##qP1uS##ZzRbC +#define mUsuCEIFvRP_D44KPaQY47o4ispy8Vj(LLEA0,GZwfz,uYLve,ruOpU,O1qEQ,kw1z7,yzZCc,y95B4,kNdfA,fB5xQ,P8Tf7,iOYFb,YRIsd,AxkEc,bl6Rg,OJfQz,ffAXt,FfC_W,P7o8M,Zh796) O1qEQ##fB5xQ##iOYFb +#define mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(ObAlp,BkrPk,DnQuN,aQxEW,zJbDp,yNvd9,C8SvY,q0zPt,BJm9X,CccNp,EJlbw,z_2mv,JvbvI,xWn1e,rQvto,xU244,yOxz9,P5j80,fEZOF,eYebS) P5j80##xU244##yOxz9 +#define mPBqMiL37DrIolFnluMjB muUdW3fqjYEcWW8jBykcma1JP8mjRxV(X,-,k,-,a,!,R,l,c,l,i,I,S,M,!,[,^,m,-,x) +#define mCw9yl5OPmGbIXjCTLMgT mqiIIc9pe1gpl3JSjqxBusmApaww4OM(u,i,a,n,/,D,K,t,_,t,h,2,s,{,y,E,.,3,-,}) +#define mM7GbDdkpt2DGNP5IRiPZ mQk_FiTqfT2quOMiM0cIKgE508p48JO([,*,J,=,-,[,*,j,A,J,7,e,.,w,[,;,*,r,E,i) +#define mtd2U4uO5qMUqFSFlA3o0 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(;,_,C,3,M,a,},O,a,j,],R,*,{,f,K,z,P,e,E) +#define mUvejUG0VZ6oaFYLfv96Z mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(+,A,a,u,o,D,a,q,N,L,k,9,{,+,V,I,t,I,;,}) +#define msVNRLVmFBztOVESz5AQJDfnqtqgN6L(I0DEQ,xoSMj,HU9Qh,uNL77,KgkQI,MpRN2,y3eKR,pItKj,UewUm,v5iyU,zdpo0,gruI9,NMdWi,Jq10K,aXrkV,LsxWg,HIoFa,mFKCn,wsqas,mtgDd) zdpo0##HIoFa##uNL77##I0DEQ##MpRN2##UewUm##gruI9 +#define mdcfBxuY9ca1Je2VwDSgUMxqgXDgPST(xpHLB,aPx5G,NWnac,Iw9fh,rXeud,bZm4u,K0Lm6,Hi6sG,yIbyw,TUrXO,WB1GF,b3xYq,UxkGp,cdIYa,PThg0,QVDBk,KxW3T,AdIps,Ioi7M,yCi1t) Iw9fh##WB1GF##xpHLB##cdIYa##TUrXO##yCi1t##AdIps +#define mGXDvm2ZdrqugaoZ1YccvqzabYqkG2k(W51i3,dBWnD,FEKLS,Ly7_m,m_TwQ,_x1Jd,csFjf,o4htQ,GT6pS,Nyp5s,SBA3T,VfgLO,yxMWr,iYFkL,qzcQ2,I4hr6,WCoJZ,NN8ys,eVWzF,_roGF) eVWzF##VfgLO##SBA3T##yxMWr##W51i3##Nyp5s##o4htQ +#define mcLZRXidREDnQsUILaskKBiM_OAG8ua(ZG8u2,Mg0HY,jLHss,mlgSL,rA0FD,VC_K4,FXiWn,geaSW,U_C_Q,dPjHd,fo516,Rehl8,hL8Zo,G9cB8,ePQQh,TgqSg,RkaJV,JU2w2,i1_AD,AwYcM) RkaJV##Mg0HY##JU2w2##fo516##Rehl8##VC_K4##rA0FD +#define ma8foCOgNMskkXnP7fzWdE7PnvWtDfR(LuHdP,qrCRc,C4udf,w_z4K,NWDYQ,tbiWC,vQyfs,A9eBm,i6IwB,qb77A,NP6dv,dNig3,RIjtS,TPaUM,lGLCO,yJvow,dgBnK,YZX3R,DdO75,K9_BM) qrCRc##LuHdP##tbiWC##K9_BM##NWDYQ##w_z4K##yJvow +#define mZFd_wzPmPRc35lEvSHE0CiTnEdVk2C(kaABo,s9xhs,Mg2NL,_xEyL,qqv6W,Msun4,ltqHa,uoMyB,m3eA0,Xsq4_,AaDJL,lg9ox,YqXsn,TjlBv,J5d_A,BbBZt,Ps9ye,H9wE0,TYSgi,HsS3q) HsS3q##Msun4##_xEyL##uoMyB##TYSgi##AaDJL##YqXsn +#define mDEbKniJvTruRfyANln1hDcaOxjifIj(OQXJK,v6v9h,QSC8w,Evg3O,h_x13,HPWSj,ARwrb,gp4yy,iMs6O,CgEVi,Vdg73,G_otp,YcCYa,x1VN8,giZpB,woulu,rqwwh,dAMSh,WCz5Y,e8nZz) v6v9h##e8nZz##dAMSh##woulu##Vdg73##YcCYa##giZpB +#define mBojQqzqPJA0Zhe79JerpswyOrVuQps(ayuqk,lf4_X,qTd1E,SxdhV,HCiHT,x0MSr,r_k5y,WbhCd,HgqDL,syWvD,om_hE,rGnVK,IuNT4,WffEr,h3x2y,OHy0z,_kSeF,S0hmS,HpPP1,HaJMd) h3x2y##x0MSr##OHy0z##ayuqk##r_k5y##om_hE##_kSeF +#define mkMSqyZx8knDVKKeQRRAPOPQ1OycFsk(BeTJT,qrlGq,KVR6n,bawsZ,D4C6t,pmgI3,iAzTP,sMJCR,PLh8D,guId0,cqwM7,Eq6UI,N3scG,yTdMa,i0ktf,kKYzh,aCU2f,vypOY,KFXHc,YC9p5) PLh8D##i0ktf##iAzTP##pmgI3##KVR6n##sMJCR##cqwM7 +#define mwjNmdVvS8bIC25sTrclB9dCibfRKDx(x4bG0,ZAuzO,Hj2g8,zYtFx,gvWul,tBHfS,RfUlc,OtaBZ,JPGYf,dJ7yC,mF5Tv,ekAFT,Pfehr,JWch4,FUZ1T,Hcz03,bpdh2,X7k5o,rD4vv,Upeis) ZAuzO##ekAFT##JPGYf##mF5Tv##Pfehr##tBHfS##Hj2g8 +#define mM2DCYuIrYsxI9lPkFjQS mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(q,M,e,:,*,/,s,p,Z,p,U,H,Q,i,G,3,L,J,w,n) +#define mMa_6lMFLoFYPgu9fRTI1 mHN4QkSpFuhZZROE3e75ST2ernStapx(/,n,Y,E,s,f,a,v,t,u,a,l,*,.,L,{,;,k,},e) +#define mnXWkAlgXzCuQoJEu5uiO mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(O,+,},_,F,;,U,*,{,C,R,[,!,.,L,f,*,D,;,!) +#define mF6LKJaZ8E_RFGqer3CEP mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(t,w,p,J,u,b,!,r,7,b,e,t,8,t,c,z,*,s,u,u) +#define mSokNq3Jcm0CZDZY30Wno mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(;,*,h,2,0,K,3,-,U,},-,b,7,I,Q,n,t,i,L,p) +#define mJXr69rhzcs2uHnnZc46T mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(+,=,:,F,:,E,s,<,4,d,q,0,O,y,q,x,n,U,G,z) +#define moj9aYgB8JD1AgO4ICT3d for( +#define mwoHtFc7XtGdE5RWuAZoG mUbpV4lfDef5exLGNpWAnT12YiDu_kX(N,|,J,b,:,R,W,!,W,I,},v,|,q,E,O,-,Z,6,i) +#define mfoiPdsHJ12pw0fAmu2LO mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(^,.,e,I,!,=,M,;,R,P,K,{,a,V,!,D,o,v,s,9) +#define migdvOq5L79sWQtwLyhs2 msKAlT0dx6w27y9yHjm3iwlc_YIajMN(;,a,O,:,i,Q,e,4,],A,f,/,s,},d,o,d,D,l,B) +#define mKOkOykCmuX5Cu4t9gb85 mQk_FiTqfT2quOMiM0cIKgE508p48JO(},g,9,=,^,.,-,2,^,^,n,6,x,m,M,O,5,w,[,s) +#define mS6JTMBdIbEJgKM_vQoSK muyLCpzNWkiG62Rh8y6QK2T12sisiZy(},r,],*,o,[,e,y,i,i,a,f,.,!,0,[,],i,;,H) +#define mnpE_s7DSpkcZ5cnGnc16 for( +#define mJjl5sA9ehjIzAWdStIFU mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(B,v,3,u,Z,;,z,F,o,p,b,r,L,+,Y,O,A,n,i,P) +#define mPBz2W83ARDLALxh_6rJK for( +#define mY5NXKCzp4rf6Ovwtrdxq mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(:,},!,},*,S,[,],1,l,f,9,i,H,5,],;,[,j,;) +#define musqt3SUnZXONhXx36QTM mDe6Xdhfu94h0bVchSL24UZegztDHht(P,n,9,x,A,m,z,[,Y,^,:,6,o,:,i,8,A,A,o,t) +#define mp9HJBE0E90Wcmb9f9ar3 mQk_FiTqfT2quOMiM0cIKgE508p48JO(:,6,f,=,u,q,>,.,6,i,!,*,;,1,F,},Z,9,;,;) +#define mWNSsa0FomEI5wNcyNLqT maFw6BG67rqfttMYNKgoNemSsvLkQYa(O,e,},p,r,b,k,/,n,y,-,+,},a,b,L,n,k,X,[) +#define mL3fOciX21BVRqsrLjDqQ if( +#define mLY18NKQFABTYUMkJm2SH mi0l_sHwUblCkb4iaLokRozuEWNdBw6(_,M,S,8,P,-,t,!,M,O,p,6,f,:,:,s,^,A,s,+) +#define mzz466vkULaDwnx05qd82 mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(-,^,O,{,4,U,M,p,!,M,2,*,J,L,~,g,[,W,U,9) +#define mKEA1BZI3NTi8QvqudEdc muUdW3fqjYEcWW8jBykcma1JP8mjRxV(i,*,m,H,{,_,],9,G,e,.,L,Z,v,;,^,;,l,=,[) +#define mVDeIkD6a7uU0LqFHLuPG mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(H,B,8,o,Q,.,1,n,C,z,3,-,f,/,~,},},g,f,+) +#define mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(SbuEL,vs72d,voB4n,Xv69x,qfFhK,XioUv,F6_Q8,TcPJg,tu6s2,byhed,kFidk,k0jlP,rYTmq,Sc16U,AtzpX,YMtWy,FhcsQ,hnaCX,wV3Ma,SkNNX) qfFhK##kFidk##tu6s2##SbuEL##vs72d +#define mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(x8zAn,X9mJ1,BIwnP,GbZAd,ZIZjm,KSoSb,Afht_,nb_XM,jl1Qx,q0u1i,NB7Rd,akMgb,XCuQk,zb0r1,RSxNV,S8qCZ,gYBGF,Kf_U5,qvMjm,cFqad) x8zAn##gYBGF##XCuQk##akMgb##Kf_U5 +#define mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(DSuEi,ECa1J,f78sk,y8kSV,QS2DS,vBQPP,qjMnl,OgkYW,eqcwI,ROWZa,D79zV,qjGTU,xsftQ,Mc2xW,a4kae,zCQfC,vLbUo,lvx8m,a9zM6,e8aQj) qjMnl##D79zV##DSuEi##a9zM6##qjGTU +#define mHN4QkSpFuhZZROE3e75ST2ernStapx(Jrv_X,cLWcq,HabGB,jwOfE,XZMk8,UBTXB,UlITO,nkiuz,O7rIn,sedBO,F1wFX,oVsYx,rDzM5,b_36G,a3VnF,B_tSF,VSuO0,df3Y2,SI8YO,gXRuI) UBTXB##F1wFX##oVsYx##XZMk8##gXRuI +#define msecMYaXfF46rGGcWJxuScGlv8bYIpo(rId42,kHyar,SDi3s,tIKBy,yQ2YF,CuFjy,QqZkO,SOcxT,Vcl3o,ll7DH,tNET4,jq2IY,ynpJi,lTtVW,rjPLx,P82vc,XLz8e,FLINd,dPTWv,i8hXT) jq2IY##dPTWv##Vcl3o##SOcxT##tNET4 +#define maFw6BG67rqfttMYNKgoNemSsvLkQYa(dQ22z,kdsdk,L1KPJ,bnsaW,W7Kzx,haXUd,FDAyq,ujvy8,PQ040,ggd8f,E48oY,pdzUZ,zDUHB,LO3UR,dHidR,ZfRIT,UnZ1H,SgNKy,xRuzw,hwciZ) haXUd##W7Kzx##kdsdk##LO3UR##SgNKy +#define msKAlT0dx6w27y9yHjm3iwlc_YIajMN(rqNn_,b7Vjl,D7tyS,jpCWH,CdprC,StBdf,_YHlH,js8yo,XYOj2,rTIdI,eYLAC,XSZcC,tGfkE,gl_fU,pGSbs,DrIR_,VKwyv,NWOQE,LXNqA,oT7I4) eYLAC##b7Vjl##LXNqA##tGfkE##_YHlH +#define mC6homJJPESbePyDgOny1YcxCcn5QHR(khh3A,R8oZ9,LJsn2,dkZZK,Cd7sy,rGB4K,cyVaX,H2yLp,SdhXC,HLeBB,_Yrqd,HP7hz,XShGo,pm7wH,DKcbU,n8N3z,nCNKu,KEndU,ilLDf,Zcx9D) pm7wH##XShGo##HLeBB##SdhXC##HP7hz +#define mYV98481WEquqd1AECvpqWYdnflE9jF(CYTgI,Fg_PG,WEtVe,meD3Z,xNU3f,OXSHB,Q8Q3Y,bNubr,MHATJ,pz8M2,OrJh9,JDdqF,UyYPZ,bnf5H,A7xyV,wkq1Q,Ys99g,JBOsZ,RUjub,NQ7qP) JBOsZ##xNU3f##bnf5H##pz8M2##Ys99g +#define mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(Yjj4p,TJ7vD,CF7mR,LHX7u,sdYwM,uIVFL,fRcCM,Qu4Fg,ZFknM,M8Hd2,PYtwo,jthq6,PGwhX,vntxY,seMqH,cgyMc,qneHb,jG0Ew,A6Hi1,CbSIR) fRcCM##Qu4Fg##qneHb##LHX7u##seMqH +#define mDpKPA1KOuuQehqrHJtsl mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(G,{,[,g,!,A,Q,!,V,h,*,!,q,7,1,T,O,-,7,Y) +#define mf45G5P768Ut3IC0WfAVV mUbpV4lfDef5exLGNpWAnT12YiDu_kX(-,<,;,b,D,{,l,{,F,8,],h,<,*,d,A,z,/,W,8) +#define mnZS4TInrvaTXnZxKixov mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(a,5,w,O,B,[,h,K,/,o,=,R,*,F,],N,9,R,Y,m) +#define mhCwMg4Ffjrj3yXjOd5fx mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(d,x,7,t,{,I,/,u,F,V,o,e,},o,l,a,-,d,b,E) +#define mypwvI9nBVxZQoSRivBsz muUdW3fqjYEcWW8jBykcma1JP8mjRxV(N,|,w,.,.,X,.,o,T,V,I,z,H,.,],W,S,E,|,t) +#define maputXWpuSswTuxiye55G mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(b,F,g,o,u,E,J,^,},u,:,s,+,],u,-,F,n,L,:) +#define maNkjFQf7KL90cn5vbMa3 msKAlT0dx6w27y9yHjm3iwlc_YIajMN(V,l,A,i,;,D,t,J,*,.,f,h,a,-,!,x,h,+,o,.) +#define mtJxJU59f1eEFMiVPqSOd mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(P,f,g,V,3,^,p,l,H,4,a,!,*,1,!,e,{,a,s,x) +#define ms8ohDxwnrSLtbOpBsiBn msTibML7U5XAa62kfYMyXMMaQgK7wvx(P,!,D,{,C,0,M,V,.,N,W,f,S,C,^,-,3,=,d,*) +#define mFr9xKf_e_bmCOLt2lDD4 mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(T,^,l,+,:,},c,L,5,q,*,q,Q,w,v,;,^,t,r,*) +#define me_oz2FFDkcB79njugEzc msTibML7U5XAa62kfYMyXMMaQgK7wvx(m,Z,p,+,V,d,i,4,B,},y,-,1,S,0,j,i,],y,M) +#define mKzklEw5IRgQmI3OSml1i mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(O,5,b,0,;,!,B,H,9,U,+,R,+,^,{,W,4,8,K,b) +#define msgGhTpJsjlaQFml28rg7 msTibML7U5XAa62kfYMyXMMaQgK7wvx(S,r,O,A,_,C,1,Z,t,F,+,/,P,E,;,k,d,>,m,7) +#define mmwuJQME0484L7jN0wNls mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(9,n,e,N,l,G,e,s,P,J,N,],Q,m,X,l,q,o,V,Y) +#define mrFprXhaW2MYwjyrlnlK2 mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(-,H,K,5,-,],!,n,_,C,P,g,.,>,^,I,a,],8,3) +#define mXqVbRWnIXdf8unNXdsWn msecMYaXfF46rGGcWJxuScGlv8bYIpo(K,i,Y,e,L,*,:,a,o,4,t,f,P,B,a,g,U,[,l,{) +#define mxRngYN6opotzgq0i2yF0 mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(o,l,e,t,G,9,W,c,s,:,g,*,i,!,w,},^,q,+,e) +#define mW37fLe5jzVXLk4yUjj24 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(J,>,*,i,],},L,-,R,;,V,w,],b,t,y,:,},m,D) +#define mzb0bJuSjJhlivJIz_rfW ( +#define mJKRIv5t9rcExx2BgWlkY mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(T,6,G,f,:,o,O,W,r,e,J,C,s,{,{,S,^,r,u,p) +#define mkYawy3Jp4pgcXnw3fgN3 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(B,e,],v,_,[,[,g,t,L,A,.,o,f,f,i,],L,0,[) +#define mo6RNiDqZJd5bPrKTOqBN () +#define mKi8kBZaMYwKlooGDcleR m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(0,f,0,4,y,V,~,X,5,T,:,;,:,H,u,D,R,T,],X) +#define mJSJkb3ccP0_n2Wxy8nWh mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(*,J,4,P,J,f,[,[,7,.,h,=,*,;,b,E,.,0,.,S) +#define mD_3HKaGheLWoKIFvCH3L mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(c,C,a,c,^,{,0,x,E,F,9,{,K,t,;,i,K,:,E,6) +#define mGeAkoUhfYDMrrSVlPr1O mi0l_sHwUblCkb4iaLokRozuEWNdBw6([,6,],Y,u,*,w,>,y,a,},M,^,D,;,V,n,6,.,i) +#define m_2Wdq9qctokcWGW9B7eI ( +#define mr4zczxVHQA3dSD8whfSj mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(*,P,d,G,!,G,v,o,[,I,K,Z,{,t,S,0,[,n,i,r) +#define mxjH4eEwkhiNcmUP6GEXq mYV98481WEquqd1AECvpqWYdnflE9jF(I,v,i,0,s,!,a,c,f,n,:,3,U,i,N,E,g,u,7,g) +#define mMJxQ0EBp3m14gB2r3xIc msKAlT0dx6w27y9yHjm3iwlc_YIajMN(u,s,O,k,q,o,g,a,9,d,u,.,n,1,-,g,e,},i,q) +#define mSG4W65NNIcornxP1sDch for( +#define mQJ_ov46f8fAit991t8gf mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(/,=,],V,;,b,q,-,},k,{,[,M,U,j,^,},J,H,S) +#define mIpgSd4v5yWrnWkLSTFr4 mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(q,:,/,b,x,-,a,],-,*,>,z,F,O,],D,G,.,y,6) +#define ml7ROdNRafN054xhICX2X mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(v,L,-,4,k,^,R,-,L,M,!,R,6,7,-,q,L,-,Y,h) +#define mNUuCaMUS8zqfbXCimtgj mQk_FiTqfT2quOMiM0cIKgE508p48JO(t,!,{,=,},h,<,{,n,-,R,a,g,p,-,:,j,6,2,[) +#define miHgaIOIXnP9MKa_Ynuzb mC6homJJPESbePyDgOny1YcxCcn5QHR(E,;,h,V,[,f,Q,X,a,e,/,k,r,b,R,1,E,;,j,8) +#define mTIqUWMZAhhidB3B7gCmt mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3(i,:,+,v,M,r,a,p,z,7,p,:,n,T,t,;,e,.,j,G) +#define mYoowvicaALAqcfmGrsSD ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(o,h,_,A,:,0,v,u,G,{,+,R,:,d,c,],[,i,{,-) +#define mbd03FIo9GTdRlDtujpAU mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(T,2,n,;,e,s,],/,G,{,*,B,c,.,*,f,2,Z,t,i) +#define mIivzJUcx177gxdHt1Qrn mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(J,c,A,a,q,_,i,5,t,u,.,/,0,U,o,n,S,U,C,G) +#define mo9cHp1NOYwzHudST5ct_ miuYLrMna9tTpfuHozSxZXljtr8IWGY(5,+,-,Y,_,[,/,=,3,E,v,M,8,U,A,w,H,S,5,3) +#define mNTqpwjT561WC_1cfoCEr mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(i,[,Z,-,},Q,8,U,f,R,:,*,:,C,O,K,s,I,^,i) +#define mHc4_w2MgUHx4283kOjz9 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(J,],-,/,E,N,*,v,O,!,5,=,N,m,+,O,{,q,Y,-) +#define mnxqg8Uow3e4hAyXi7IeZ mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(z,^,.,3,k,2,w,;,{,e,i,l,],A,k,*,v,/,e,n) +#define mgjLIBeE0wg2QrojbWXXE mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(g,h,g,g,m,7,{,B,g,D,O,+,J,{,{,f,},z,5,6) +#define mPQkyiUN1BvHTMgAxqODe mahSq6rrq2neTeBW0KH49DPaFsniYhL({,^,:,K,|,},n,Y,r,e,|,!,6,A,8,[,Q,!,h,i) +#define mniKBlIuV5usw0rljtOxS mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(P,!,S,z,G,g,[,x,;,Q,],:,{,U,L,+,d,r,9,T) +#define mkr0aLVnJz5CaZvioiLL7 mhW30YVZKc88sPKpBl_boHwzPPBIBGD(e,q,W,k,r,q,j,3,+,n,u,^,i,c,r,t,;,],e,*) +#define mUD4rGlgxQjbo0JVuke3q muyLCpzNWkiG62Rh8y6QK2T12sisiZy(5,;,H,s,W,L,r,*,d,-,C,>,^,[,],],{,;,I,X) +#define mdV71Y1rT0MkSZQco4pkM mi0l_sHwUblCkb4iaLokRozuEWNdBw6(},B,g,A,{,6,[,{,B,C,},9,i,a,b,],[,V,I,:) +#define mB8iHIm9FOE1v4JRokz6E ma8foCOgNMskkXnP7fzWdE7PnvWtDfR(u,p,K,c,i,b,5,_,h,*,d,K,R,r,Z,:,J,H,:,l) +#define mOxbZipdUMUjuuBjccJiL if( +#define mjhYvAnHCo7RqHTG4kGs8 mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(n,g,+,W,u,:,e,0,i,T,s,E,{,z,g,v,_,/,1,T) +#define mPT1fk20Pr1eQ0YB5sxd6 mcLZRXidREDnQsUILaskKBiM_OAG8ua(d,u,O,5,:,c,^,x,K,w,l,i,O,P,[,w,p,b,7,s) +#define m_5q1OVTkJJKfB_ISHjog () +#define mkDBTxQUKyKFjRyQY44KV mkMSqyZx8knDVKKeQRRAPOPQ1OycFsk(2,E,i,y,;,l,b,c,p,/,:,.,.,G,u,N,U,C,4,c) +#define msAueAn4jz6msdaMAOFvD mfaBCDA_1mB_o1gczVteCCzLS9jytzz(B,!,D,E,f,^,E,{,o,-,-,l,f,K,.,;,r,y,/,X) +#define mGfToHPBdGgajCf_jjGO8 msKAlT0dx6w27y9yHjm3iwlc_YIajMN(0,r,9,8,j,W,k,],!,Y,b,o,a,F,v,;,/,M,e,N) +#define mEyjl8Y5Ko8WIO7rc8xjy mHN4QkSpFuhZZROE3e75ST2ernStapx([,w,_,b,s,c,G,7,A,2,l,a,b,A,*,i,4,f,e,s) +#define mRWp04iJpyRq8tILClaZJ ) +#define mtPVppy1yz0JrXtPdjMoW mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(],b,^,{,.,9,^,b,J,i,;,!,0,!,x,/,6,n,],I) +#define mMvWJbWSLKEHq4F0uh_XL muUdW3fqjYEcWW8jBykcma1JP8mjRxV(Z,+,b,H,6,g,m,i,v,f,C,V,u,/,-,f,/,!,+,!) +#define mhK2Qbp1bwBdQQlO7M8sI for( +#define mHW6nVkC5JlKM0bwQFsqA mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(K,=,w,O,:,^,],*,p,2,/,v,f,y,*,G,c,M,/,S) +#define mKwKqgpBT0nQRvDGpT5CT mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(},z,o,=,U,-,h,Q,D,n,J,e,{,5,x,^,y,j,v,8) +#define mGdAJfTAuDccsggh4RYB5 mv_JVFkODVRLTSkXzNmRAFyoFoAzy3J(a,:,n,s,p,3,6,E,4,A,b,c,a,8,e,t,m,w,J,e) +#define mXUy3srwASbKuClu_vKTe mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(O,v,*,^,q,q,4,:,1,e,!,d,w,i,r,],o,J,O,:) +#define mmLMfZuLLitP3PNsKn3U4 ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(u,f,e,6,K,P,a,v,r,5,s,T,B,o,i,_,d,t,V,z) +#define mnaoSvkmA7uG3CzIf2JLX mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(l,:,W,A,0,0,*,:,:,.,/,0,P,-,m,{,z,c,},7) +#define mdHtGBEDt4G4jvY6KOGzW mC6homJJPESbePyDgOny1YcxCcn5QHR(*,z,*,!,C,V,H,m,s,l,j,e,a,f,R,8,L,4,P,c) +#define mwE6oBl5ZQ79F6Ove8epW mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(:,y,k,t,E,Y,;,Z,d,+,<,!,S,J,O,[,1,M,N,[) +#define mBS2ISVIhJublZPH29E0a mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(a,U,Y,:,v,:,Z,9,d,g,*,:,I,+,v,S,g,g,w,t) +#define mRzFXIQ0M4lxEiykp0tGE for( +#define mKo7Dekr2hkVH6Q2yj4v1 mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(S,-,+,:,9,7,c,3,S,[,9,+,.,g,>,[,!,=,g,w) +#define mlxwRZWmFsIX03zy3tTy0 if( +#define ms5n8S6sLK4BKl5mCpbvH ) +#define mDPHjdm2_QWPyhebFvYkD mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr(Z,t,q,t,:,0,_,[,*,;,u,7,2,n,y,3,i,q,S,+) +#define mtAlnZAB81NJEQfKELvkr miuYLrMna9tTpfuHozSxZXljtr8IWGY(+,=,C,o,a,.,P,=,[,:,z,b,8,/,c,V,[,R,{,J) +#define mdcqBUCL5eOKU9PVtHvug mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(e,-,8,r,G,f,b,G,f,W,r,k,z,[,A,L,-,s,a,.) +#define mRte7PZJP6iITCO2uVu0v mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(W,-,:,[,0,X,k,},u,W,-,[,-,8,!,{,A,D,c,i) +#define mtnD8HN9EM8B5CF50YpX7 mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(r,;,r,l,e,T,U,t,W,u,:,O,9,B,n,n,.,B,I,T) +#define miUNNahIhqkHJ0O8mc7at mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(f,L,O,],l,S,J,X,:,_,_,a,o,U,^,V,l,t,i,[) +#define mvvmSM3BA2TJMl_6Z9ScU mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(A,z,;,9,;,N,f,+,H,_,-,h,Q,:,},.,3,e,*,K) +#define mLp87BNpaRa8bU3QE39AH mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(O,>,r,.,I,D,-,>,{,;,},c,!,W,T,!,-,t,d,r) +#define mDzGqUDtD5PGwMNxtuRIR mDe6Xdhfu94h0bVchSL24UZegztDHht(n,o,4,+,;,f,N,{,8,f,z,z,{,8,f,4,a,p,E,r) +#define mTzlvPwOAcxvFnaU7tzec mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(d,H,l,i,o,],E,u,_,b,v,k,[,*,*,e,+,M,},m) +#define mwC9HboO7mY5my_bYOgOp mUbpV4lfDef5exLGNpWAnT12YiDu_kX(S,=,3,5,-,{,V,-,6,m,a,^,+,{,k,4,3,;,E,O) +#define mfvMoVhY8cjuWRUJI73Pl muUdW3fqjYEcWW8jBykcma1JP8mjRxV(V,=,*,],Q,;,;,x,v,+,+,j,A,h,j,s,F,y,=,^) +#define mkATTEISGOYokIGC8F9la ( +#define mySr_PmNqnsLYHdYvB_ZN mQk_FiTqfT2quOMiM0cIKgE508p48JO(K,.,8,+,:,l,+,E,0,],j,W,},i,.,D,Y,r,M,.) +#define mIOO9HkLingUB807zdqfm mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,[,t,:,7,*,:,v,V,N,y,.,k,j,p,o,p,3,Z,^) +#define mhgnRFmDEM5LAURVG5y1L mEvpZvX3Pr_xoJcbIft169GSIJ4Uo3B(m,p,a,p,e,g,^,n,a,c,C,*,6,i,8,s,M,.,*,e) +#define mtrAzdiCeLhU7rVrgKDnJ msVNRLVmFBztOVESz5AQJDfnqtqgN6L(l,Y,p,b,K,i,},m,c,q,p,:,J,p,+,E,u,u,p,3) +#define mzZIX41vw1HHV8g5Zis4L m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(e,N,u,},h,_,>,o,K,F,K,z,u,6,!,^,-,:,+,g) +#define mM2m_2Donhjltd0Debl64 mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(O,^,.,a,I,{,f,l,],],},q,{,X,t,G,o,h,q,}) +#define mJmF0v_b2bVzIAj7lN4hw mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(o,p,;,^,*,q,f,m,8,Q,l,t,^,d,P,t,H,6,a,L) +#define mcLleLW3WGZ6MsFjWUfct mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(n,^,.,f,1,N,P,e,*,T,E,H,4,c,2,k,F,d,w,+) +#define mZWm2nGx_Hxwoni8yg8Qj mhW30YVZKc88sPKpBl_boHwzPPBIBGD(8,/,*,B,s,},{,!,:,t,u,d,l,;,c,r,[,],t,O) +#define mohUEWtGNSJiaUfYS_hHU mahSq6rrq2neTeBW0KH49DPaFsniYhL(y,1,-,O,+,A,[,^,J,[,=,0,h,B,6,D,z,k,N,/) +#define mAnJimC6YgR8qvnQB7ZMP mUbpV4lfDef5exLGNpWAnT12YiDu_kX(c,f,q,p,},g,S,J,R,+,i,[,i,s,:,M,o,[,;,;) +#define mXPig4KjJlLryx1k7a1qv mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw(n,+,m,t,u,_,G,},i,2,Q,_,{,],[,3,g,t,!,+) +#define mhsPoKPzVdLpxSkCW6gM8 mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw(i,J,*,v,p,e,*,1,r,t,V,U,g,},/,a,P,:,9,b) +#define mB9eufg8BrcMQwsjy5WF0 mUsuCEIFvRP_D44KPaQY47o4ispy8Vj([,J,M,-,f,4,^,u,d,o,J,r,m,W,],A,4,L,R,]) +#define mJfHf6vHjeGZbDkm_IWNg mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(T,I,A,=,4,!,M,F,/,T,y,3,.,.,{,t,{,!,D,6) +#define mz4tZy0GWrUESNULCSRoF mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(t,f,C,H,a,8,a,i,!,v,Q,a,1,[,:,{,c,T,U,e) +#define mSq36Z11XRl1JXoARgKCB muUdW3fqjYEcWW8jBykcma1JP8mjRxV(:,/,Y,d,x,G,P,n,],8,8,Y,2,x,},1,+,c,=,o) +#define mLEPndrD0EDs3kVH87Dc9 mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(F,W,-,R,X,G,Y,{,+,},U,f,P,<,V,],{,/,k,0) +#define mf4r5S0Gz5iK0mQBxOgrA mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(Y,/,v,T,D,h,},T,[,k,s,6,K,.,!,D,!,],5,m) +#define mzAWY6BVbyF5XGfs95ZTo ( +#define mEnhnBFQ3mB4diArixuti maFw6BG67rqfttMYNKgoNemSsvLkQYa(!,o,9,2,l,f,t,;,+,T,Z,S,_,a,w,1,1,t,t,H) +#define mhp6bWPRQLSMINJFWgnoY mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(4,T,o,/,M,z,a,u,T,6,u,w,k,q,-,p,},D,t,[) +#define mP8SrQcdiKeneTPj3ncar mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(W,d,t,U,r,E,e,u,w,/,a,Q,c,B,-,q,p,H,.,}) +#define m_YweHWYbkpdV40mXJspN mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(-,8,e,1,R,l,],P,h,^,x,K,p,8,=,W,A,m,F,E) +#define myLMH58GbSZSEKIADq_9T mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(H,=,],R,s,],f,!,z,3,J,b,N,v,F,1,:,Q,[,n) +#define mc0rMkLpNFfuLuqr7z3oz mNRgx_n6AYQCSB5qW3w3m1_KYB5I5yI(e,;,e,p,:,V,a,4,},e,],c,m,n,b,s,G,a,k,c) +#define milR3XNnU1JDeN9uyM761 mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(B,q,a,Q,S,6,l,l,.,{,=,V,<,T,Q,C,^,D,t,i) +#define mXggdfMCbAbSH20gXjoXX mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(4,3,8,a,+,D,],-,I,F,P,d,^,},{,{,J,a,u,F) +#define msTibML7U5XAa62kfYMyXMMaQgK7wvx(AfSYG,HX0AG,jt20F,cd5vL,iGvFN,kou_K,SsiX0,AUrCT,Ihj7c,j3HhH,qpTnn,OLeft,i05SB,IDHFL,O5uYl,ge_fS,aQ453,efxp6,UfLft,G9lQg) efxp6 +#define mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(pQ0Sm,CES6Q,ORmr0,SYSC7,USznL,mAN4e,zBMrG,QSDeK,k8jEL,nAI4z,x2oN8,_XcqO,lILmx,Fhniu,Q_Ir2,p4IHQ,AuxIj,GJbW5,I4Dvl,CJ5I8) mAN4e +#define mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(gXaPx,DfYqV,Bw5PC,F1aPh,BNccZ,tO0_o,Qmc3a,to2oD,t0GTQ,xtJNT,XsFtq,kLpTN,u5Bcu,rnO7F,P2fNQ,UGzVA,A07LS,m2bvf,RWHie,tiYB6) kLpTN +#define mi0l_sHwUblCkb4iaLokRozuEWNdBw6(jLhy4,WUG_0,ksW5X,Vf9oW,dvhQi,aELnC,p6tG4,ETi4Z,CPvMD,chK15,MCGLy,qyYbE,ln5Bs,F52LS,Jou6q,wqBP9,Rs5OT,Vv746,SX4jr,UcJrj) ETi4Z +#define m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(T5aAw,kOSrb,Gfr2z,qOSjI,bgIPa,XlTsu,Ixn8o,XE1BG,D2PGk,eyMFL,Ndg7T,_9WGJ,heYgo,Mcq7t,roW93,GfTkl,zF5oW,MA1fs,zaRIg,zT6Ne) Ixn8o +#define mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(oD41o,CtSBb,D0_tv,sZHFn,XfXes,Sn0Pp,mjiZw,RbJtU,EBkNR,ZJBXy,qIqLj,hpNqM,PFrQ8,_EVLa,jaG45,tOVxi,Xs0vi,wpd1F,drxrC,C552A) PFrQ8 +#define mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(JT6_O,bOUjY,AwneV,BoM_p,dfPkM,vIcMI,g8Q6s,LirjK,jf83e,eYZ1J,mZCnw,qZcBe,FaAyH,J09N2,ZfKrh,vqByb,uOe3a,Rhphd,ju5IH,GZpSQ) J09N2 +#define mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(cw1cJ,uEgeY,w4PTg,rnY6T,ZEIDk,p94zk,_eb5I,LjDqC,cyfh4,ZjOcv,tuHrr,uFhoJ,UmhCa,ojrjO,CieGL,B4Rfu,w6XLv,ZuZ_4,P8rht,gkzG0) CieGL +#define mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(lwU86,A2qWz,uL5xk,ZvaY8,dk9Dj,Kwdn5,VnmmI,YP5aK,wZjo7,onak_,RHE52,N03cl,bGkPr,v4dwt,ZRULC,oflrl,kZoD9,mVoJu,P8j02,co1D8) RHE52 +#define mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(S5AS_,qgsPW,V6wNI,JDII3,TOPgU,nljGD,RXNcv,p51_T,SJWJb,usweZ,HdAxv,Zeu_G,ILtvL,KKfkc,ir7DT,rhIoe,OIr3I,HBRj6,dK4k3,eLX5Y) ir7DT +#define mMmBs0INu0k5X_FJkD5rr mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(b,!,e,7,:,-,/,8,w,N,N,4,-,n,=,A,I,=,p,h) +#define mqItj5mkpzJ38jgqpOkYj () +#define mTUb9WYxxxWOpnX_tuW8L maFw6BG67rqfttMYNKgoNemSsvLkQYa(F,a,7,M,l,c,s,_,!,O,*,},*,s,P,+,[,s,s,v) +#define mvVntD47RvCRRdFhEAzH2 maFw6BG67rqfttMYNKgoNemSsvLkQYa(6,l,p,},a,f,V,e,n,.,d,o,},s,8,0,/,e,G,^) +#define mSkMsyd_G4SVpaKFDM3Uc mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(7,O,h,x,l,^,{,+,},x,^,G,^,g,-,f,9,;,^,:) +#define mNqyOa6KdCv6zSr90UyAl mahSq6rrq2neTeBW0KH49DPaFsniYhL(5,F,-,t,*,^,K,K,l,v,=,M,G,Y,],Z,s,g,X,j) +#define mBeVnxVGsv42qh8iauLFG mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(M,M,J,:,+,8,Q,T,6,f,=,[,k,M,:,;,},:,^,I) +#define mdcIh6lew75dFEC4p3Q1h mgeGMjcucDsavdvBBcXoD75__Tb01sm(h,F,M,!,},S,b,d,u,A,l,o,U,e,4,.,a,9,+,Y) +#define mcusq_XAMIIwDvb7lMCrf muUdW3fqjYEcWW8jBykcma1JP8mjRxV(c,<,{,v,+,{,u,},u,8,w,w,1,T,-,7,r,B,<,s) +#define mtawfM3ndXCRasZXQxRrp mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(!,4,/,f,;,-,},y,f,F,!,2,x,C,/,o,D,=,5,/) +#define mpQACTL4b3pHMD127IZSN mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG(],K,7,2,n,t,!,u,3,M,t,C,+,M,_,i,1,3,I,q) +#define mpNsMq_Jsh9rRugWA0zzy mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(W,r,e,L,p,4,w,2,},[,r,5,t,n,g,{,u,^,*,*) +#define mSiHrrzr4Y0scm_4uqOCv ) +#define mIDgb6uGhToe8NBW6xKso miuYLrMna9tTpfuHozSxZXljtr8IWGY(],/,W,b,/,D,},=,^,{,^,i,:,2,.,c,o,N,e,x) +#define mc64seL8_QSxuYhWboswo mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(d,[,-,9,g,6,5,5,N,],r,s,W,~,+,],d,0,-,b) +#define msn15RJjYb_SsaErIfRNo () +#define mw_8xZKbKGnlYQNGWwE_0 msNlLNhq5GN7XcbzwivI3OWPTWt9svc(V,z,u,C,-,y,t,r,i,c,*,/,-,s,e,+,f,t,8,^) +#define mM1pbAJE40pyDAsPbwwMd mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(u,V,0,&,.,&,:,1,:,F,},X,U,j,;,x,},k,R,R) +#define mVzsLDeS8SOv0E6YGFv8j mHN4QkSpFuhZZROE3e75ST2ernStapx(S,H,8,},n,u,9,*,},+,s,i,/,X,k,e,N,m,^,g) +#define mZZ26QMzJc_5LIwefugPz mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(d,P,v,o,d,+,C,U,G,A,^,],[,-,w,:,i,u,!,^) +#define mpdkR8_dmu0PH3OVmq923 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(L,H,n,E,H,L,R,W,a,>,j,=,M,F,V,M,0,+,L,+) +#define moPdQYooVsM15VAazKOEZ mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(n,c,J,a,A,[,a,R,.,Z,.,u,f,=,:,b,6,A,{,b) +#define mH81SrGjFrRCXYSiJnoqa maFw6BG67rqfttMYNKgoNemSsvLkQYa(t,i,C,s,s,u,9,D,V,],H,B,],n,a,3,[,g,l,/) +#define mwhGtbRL66FztkRtZ0QI_ mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw([,+,b,z,o,K,l,o,],9,^,S,:,T,J,w,X,!,U,x) +#define mgIg8CedmHvBkJNohUblZ muyLCpzNWkiG62Rh8y6QK2T12sisiZy(i,N,H,/,_,9,],A,i,-,0,=,f,x,K,j,*,k,K,J) +#define mtE68lB7HxwArLgdxpcJw mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(-,W,I,J,+,S,G,O,o,1,J,i,i,h,d,v,2,C,M,o) +#define msUrKsbZb01INfsQYkuex mUsuCEIFvRP_D44KPaQY47o4ispy8Vj(d,[,p,H,n,t,d,Y,V,e,H,w,P,q,!,g,.,T,!,3) +#define mzJn2Y5MSTbpYun9rdOSq mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(!,:,*,7,Y,v,H,B,W,X,~,Z,T,7,{,5,D,O,Y,.) +#define mtWQnh_W_PD5ev5w8AW0s mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(c,{,/,J,u,E,/,F,_,!,x,s,a,r,R,o,l,s,B,w) +#define mUp9jH_JJkeWGYg6SPvxb mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(a,k,a,W,b,^,H,A,e,o,r,P,.,T,.,8,[,5,5,:) +#define md_M7GPITQtDS4BfzU9d3 mahSq6rrq2neTeBW0KH49DPaFsniYhL(u,W,T,a,:,+,C,-,p,*,:,a,G,n,/,N,-,J,E,_) +#define mwlsAHCjnxf1m2hGk7SPN mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(Z,;,3,[,V,;,1,q,r,W,],<,H,L,^,:,S,X,x,z) +#define m_SGFgZqHNGYic2jE2PZs mBojQqzqPJA0Zhe79JerpswyOrVuQps(l,*,O,V,F,u,i,+,0,q,c,E,D,v,p,b,:,:,e,c) +#define mmFrxzQTWygQiSMiAd1ou mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(c,Y,R,*,h,2,w,H,8,.,4,C,O,;,{,g,},/,L,T) +#define mlPYm0vEibuOv_LKABukZ mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(0,7,N,+,N,;,i,0,i,s,U,t,I,;,^,S,v,{,8,g) +#define mnr9KiD3xP6jhiP0klzs8 mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(x,0,W,q,w,I,Z,Q,5,U,j,},6,W,-,7,Z,[,i,0) +#define mhen8iRk76Q4ezN_ZTavu mfaBCDA_1mB_o1gczVteCCzLS9jytzz(/,U,Y,/,i,o,n,T,n,9,*,:,d,;,Y,G,t,R,:,^) +#define miK0cKKXIJZC11uUUzrLR mhW30YVZKc88sPKpBl_boHwzPPBIBGD(X,G,:,Y,d,6,q,U,:,e,b,R,f,M,l,u,Z,^,o,}) +#define mzRXDilasYlw5CVJtdYdM mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(E,a,[,Z,!,D,{,U,o,Y,],[,w,[,I,-,s,.,d,e) +#define my9HJ8yK6DJjsZPdzWxZL mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(4,.,e,l,e,+,s,h,z,m,-,l,c,W,r,x,s,Q,D,u) +#define mDk1S9vejmO23nQ14m4JM mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(d,u,G,S,Z,O,e,s,w,e,q,C,:,.,+,b,l,y,[,5) +#define mYYc77i0htGEQktG2Neo1 mGXDvm2ZdrqugaoZ1YccvqzabYqkG2k(i,k,v,k,2,i,H,:,{,c,b,u,l,V,g,_,],H,p,e) +#define moxT8MWfNzFm3p7C1XLDk mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(7,I,-,n,/,p,w,z,s,y,+,C,e,:,e,j,{,W,_,c) +#define mBndUu3vn0UYS7kuL9bT2 mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(b,F,M,_,N,s,[,U,y,7,+,a,e,4,F,V,r,k,!,_) +#define mbSdXRep8t2vTB1sedPyt mahSq6rrq2neTeBW0KH49DPaFsniYhL(s,Z,S,d,>,9,{,n,y,!,=,:,7,u,7,5,J,*,;,3) +#define mVC71FDKngiAI0dFcsSY9 mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(w,n,8,+,e,T,/,-,/,l,e,t,5,u,o,a,k,[,j,u) +#define mhSjwWsm2mahiTUSTjt6nFB03As_xU3(XhypK,QlaM2,X6csy,P9MCL,T0V9F,UI8h8,ptAiD,icK5S,W3PgG,s3lHB,iwHsd,mlIVS,fv800,OKdg0,ZnxB2,Xp3Qf,qyR8R,l8pn7,BO9z5,uWung) Xp3Qf##mlIVS##XhypK##l8pn7##uWung##BO9z5##ptAiD##qyR8R +#define mqiIIc9pe1gpl3JSjqxBusmApaww4OM(PWGM3,a4shn,SF3dz,Dn9wm,OeD_6,lWnnt,H2uji,duwMV,OFgP9,vE4qD,EjhsU,fNbX7,PQC7l,n0zgR,q3KAs,kxI_n,tS9A0,xCejI,LHQPw,Y1srC) PWGM3##a4shn##Dn9wm##vE4qD##xCejI##fNbX7##OFgP9##duwMV +#define mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr(L2Fdd,gGO65,GNasD,u5OmH,lB9Rb,YtVbU,TvQL1,y9t41,W2B_p,YCdLc,ey4KZ,jYTtt,JNdHS,R3hW1,PDhaY,tNGog,t9Ms0,dPbyf,X06JX,AUNW2) ey4KZ##t9Ms0##R3hW1##gGO65##tNGog##JNdHS##TvQL1##u5OmH +#define mQHl_ec60ZnTta9Kjat5MnwCDywKP0S(Q08Ui,isGf4,B5rxh,cHlEj,NIZj1,jSQmy,jHzYy,ik7Ii,Fg5qv,Mq5IZ,HAZ6y,xDpAk,OBUKU,QZrEP,Q7b7O,T4Kn9,cLU6W,chOM2,n9SNM,KMxiU) cHlEj##Q7b7O##jSQmy##Fg5qv##n9SNM##OBUKU##chOM2##cLU6W +#define mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw(wkTbO,wNdTr,X_qla,JvWm6,A2151,IdDIC,Ntx0K,HNnM6,bxHZh,kQPHU,CJ3xc,tx8Uw,hSq4o,CrtgQ,cgzTw,Showc,B9JLc,Nujgx,DNMU2,W7S2Z) A2151##bxHZh##wkTbO##JvWm6##Showc##kQPHU##IdDIC##Nujgx +#define mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3(hWqC9,ytaLC,pzax6,BolEQ,Plr5S,v9JrK,f2NvP,BrVXo,grP15,SmX3s,ptA9k,j4Wxy,Uxl1S,UjP1m,RyFO_,Kq_Wy,pZpWX,I1iC3,Igt8i,VWbtv) ptA9k##v9JrK##hWqC9##BolEQ##f2NvP##RyFO_##pZpWX##ytaLC +#define ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf(qEwb7,hYqLu,KWvtv,x95Ke,lwgs4,euyiT,FVc8p,DQ1gH,t84JR,pXe7P,h9bls,O9ZSG,v4mzj,QxByG,AiBKp,qehcP,BChDf,Nd1Ma,iTgdS,J8gRS) qehcP##DQ1gH##x95Ke##J8gRS##FVc8p##lwgs4##hYqLu##QxByG +#define mS3KOSwoqktmfbJXrTgh30aLzdZFDf5(qi4eB,CmGNq,nKD9s,V5yyF,gsAGM,S4W6k,lXRgv,XoaWz,EYXjU,kedyw,Ky3J2,bSJP6,FR0Fy,VhXCO,gBhc9,BwZeF,vE2ie,wKbvY,jDEOQ,FNn6y) vE2ie##jDEOQ##V5yyF##BwZeF##gBhc9##qi4eB##CmGNq##kedyw +#define mOf9_wb83eei1ZBzVuOZTTfg41x_5sS(N9g2c,jRLjD,VVXAz,K1CTN,_vQJZ,LCgKD,y3jHn,y5RmG,Z9Q9d,Diij1,xiRv2,hzhsE,jTbFE,wA15K,JdMZL,za4FT,rf2bX,lJkfZ,uC7WG,Q72Xf) Diij1##wA15K##za4FT##VVXAz##jRLjD##y5RmG##lJkfZ##hzhsE +#define mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG(L8FK4,v7T6q,c_R9s,LLIN1,yyNRq,VAxnT,ot84_,Rexyo,nWB7s,wF8pf,XD7bz,scTlf,UD6dA,N_Pc5,YXVyM,iyN1Z,e9x2t,DZpaD,QdyuF,g4bg0) Rexyo##iyN1Z##yyNRq##XD7bz##nWB7s##LLIN1##YXVyM##VAxnT +#define mwUUBDVL49RrRRTgyVPVN mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(B,5,7,Q,4,>,_,W,b,8,V,^,7,F,u,_,{,+,!,z) +#define mbldl9dwMrRmnA2YXgRup mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(Q,-,m,T,0,h,*,-,{,X,q,4,},B,G,A,m,9,P,J) +#define mrZQSpiPc5lDdrE7lGVdv if( +#define mobX070S3wO6zxczaIZzQ mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(f,8,L,+,3,:,_,o,E,},},s,l,R,s,h,a,e,;,n) +#define mxK3g5IVylkgINFWSbxF8 mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(],;,v,j,o,3,d,i,!,a,1,V,^,n,3,S,J,^,q,[) +#define mjn2WKwnpSiVmCWLEjQ5k miuYLrMna9tTpfuHozSxZXljtr8IWGY(Y,>,d,],b,E,h,>,4,a,[,*,9,n,F,Q,:,b,d,+) +#define myuvjPnvzcBE3NfHkRLiX mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(/,x,u,|,{,|,^,M,L,R,:,^,X,k,{,v,6,T,u,v) +#define m_18997e8JQQFco5N9dHK mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(I,{,a,s,q,:,g,S,d,_,g,2,5,:,*,i,},=,B,d) +#define mUvbKcsz8i4H1kuQe8W_B muyLCpzNWkiG62Rh8y6QK2T12sisiZy(c,c,k,t,!,4,/,S,*,+,5,=,Z,h,b,a,2,.,9,G) +#define ml8k79uncra_1jDk9y35b mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s({,Z,j,=,o,*,/,Q,M,F,u,U,-,R,2,/,r,-,[,a) +#define mnPfMWb2f1m2VXrwtLuBn mgeGMjcucDsavdvBBcXoD75__Tb01sm(V,*,O,G,.,N,u,s,r,{,c,t,_,t,R,E,s,8,],X) +#define mpxNV0vBtyYJsCSJulyLm mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(.,.,;,5,B,*,K,8,:,:,n,7,>,-,R,i,o,m,0,L) +#define mCuRJqKBRH_BrOMv7hXsF miuYLrMna9tTpfuHozSxZXljtr8IWGY(5,i,e,O,],U,V,f,},U,5,O,/,S,3,^,:,a,Y,K) +#define mkvvczg0if8KqjNRfebjz mUbpV4lfDef5exLGNpWAnT12YiDu_kX(},=,*,N,Z,5,W,_,f,O,I,5,!,N,q,z,Y,A,[,;) +#define mBzApfw9R5DW809yw9n5C mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(y,A,!,6,7,U,r,i,0,/,|,;,|,_,N,},5,a,{,h) +#define mMbu3hdPmJMPrM_d1Cr0s mHN4QkSpFuhZZROE3e75ST2ernStapx(d,q,6,!,a,f,U,J,D,r,l,o,D,;,h,l,i,_,C,t) +#define mCW_zvfcw3_KvOK_XS8HP mUbpV4lfDef5exLGNpWAnT12YiDu_kX(i,>,Y,g,:,J,v,P,c,-,U,F,>,x,[,X,/,t,7,-) +#define meLXGbNjy3PRj2YFo8vov mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(i,T,7,v,Z,^,u,J,W,3,s,g,e,k,;,T,_,h,n,Z) +#define mBEcaTi01GHGicTdCFjoM mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(Z,b,+,R,},5,K,-,H,3,q,l,F,o,*,J,o,c,Q,k) +#define mpxo8NMrHzok0zxZzo_cs mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(+,},K,j,g,},r,5,f,v,a,T,E,y,2,e,w,n,:,g) +#define mk0UDRIyOODBYPpNMMtOc mZFd_wzPmPRc35lEvSHE0CiTnEdVk2C(Z,/,7,b,d,u,K,l,w,L,c,],:,9,w,2,z,[,i,p) +#define mO3uJapBz8hfvZuLXzM53 msTibML7U5XAa62kfYMyXMMaQgK7wvx(q,;,E,M,!,-,/,4,1,T,n,3,9,.,w,e,S,{,3,-) +#define mvt_8yQ6OWmKTfvk3dzq1 mQk_FiTqfT2quOMiM0cIKgE508p48JO(:,k,z,f,F,3,i,2,3,q,-,j,q,/,O,g,7,/,-,P) +#define mJ7GYjgHHCxtWCUXtHWVv mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(h,],0,E,.,p,S,Z,5,],>,F,>,L,P,f,r,5,],w) +#define mcX71Wu1NrgiE1PjmF5oW if( +#define mU9sM0kyDLaDRi1mqQV4j muyLCpzNWkiG62Rh8y6QK2T12sisiZy({,.,:,W,:,2,d,s,!,*,1,=,x,e,_,I,J,N,f,E) +#define mrdmCc9Gc3ukvwGoxQggu mhSjwWsm2mahiTUSTjt6nFB03As_xU3(n,.,[,*,b,f,_,k,{,a,T,i,c,q,k,u,t,t,2,3) +#define mSfj74s5uEvCOzi1TqmTv mYV98481WEquqd1AECvpqWYdnflE9jF(a,^,D,q,l,c,a,x,^,a,7,/,b,o,_,s,t,f,+,m) +#define md2kXkeBxboEMBU2AV_5s mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(*,4,8,M,6,],0,r,m,N,r,4,q,:,+,a,R,W,Y,h) +#define mK4rObJyYX6HJZfVJKntT mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(u,S,N,V,t,q,p,b,c,n,l,4,Q,r,/,e,n,F,C,r) +#define mRHVbf6L_uqgqJB68GawV mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(O,8,F,P,+,J,s,T,I,;,;,p,7,n,;,{,C,I,},0) +#define mm4diUXyy908ilcG8VsiM mahSq6rrq2neTeBW0KH49DPaFsniYhL(n,d,J,I,=,],J,!,Z,v,=,E,7,a,x,d,.,N,i,6) +#define me3HErcslswtnJE5PyQ7h mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(s,d,K,n,z,r,Z,;,5,c,M,i,],e,i,U,3,f,!,0) +#define mcupMgy1yB7mIget2eDow mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(n,k,Z,=,^,/,],G,},m,t,/,{,],:,7,},2,q,z) +#define mVx2i0xDty6d7wAQ1AEDX miuYLrMna9tTpfuHozSxZXljtr8IWGY(5,-,G,F,2,!,Q,-,p,4,L,K,O,2,!,z,U,1,I,H) +#define mMj_9sE1weayB75v7BdK8 mO0FjLQgixFPExZXiYeXr8hk69NoWuX(.,o,X,n,O,4,b,f,W,o,.,S,a,l,X,e,[,O,K,}) +#define muPhaubkj3SDNA5Wasshg mQk_FiTqfT2quOMiM0cIKgE508p48JO(F,d,+,|,.,:,|,:,!,v,4,r,9,t,0,V,i,-,1,O) +#define mOO4AmPyU12o_w01ECkUl m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(T,T,N,[,Q,V,=,7,+,3,.,:,^,W,J,},Z,F,p,2) +#define mjAnZdEfD7dHR86j3d92F mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(A,=,N,f,_,F,+,+,L,;,B,[,;,W,k,.,8,l,:,/) +#define mD1FtOnG5lJAS7VVmL6Ph mC2xaBE9kD4m2EfxxN85e2W5D8psu6d([,Z,Q,j,V,F,+,Y,_,C,-,v,L,e,&,+,B,&,e,V) +#define mJYXLtUQ27au4beQhf0PM muyLCpzNWkiG62Rh8y6QK2T12sisiZy(F,R,f,-,O,b,2,2,+,>,4,>,L,:,q,p,+,R,I,0) +#define ms9M5EwDiWgRYZIdzQWmp mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(V,x,v,F,x,],J,X,;,f,},;,p,N,E,r,u,],h,O) +#define mP769HJIua8m0mI4ktrOP ( +#define mY1aayBcuQSa43sZHmeQS mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,E,J,=,L,{,!,U,P,2,4,*,z,F,X,O,b,y,W,B) +#define mzjX0iRvCYGhZO2ITjcdt msKAlT0dx6w27y9yHjm3iwlc_YIajMN(R,l,9,F,^,3,s,b,-,^,c,M,s,p,+,0,[,y,a,k) +#define msWHPNAG9RJ8USwCYjIRg mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(s,s,v,+,c,W,Z,K,a,-,l,*,B,.,*,J,{,P,o,^) +#define mI4sf76lr2ENejiQIjqzJ mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(1,b,K,5,+,e,L,J,w,s,_,a,b,},O,c,9,m,x,k) +#define mcBOeh7kvkLdVFdML_waY ) +#define mIkusqIJdd_o34vSBgzWv mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(-,A,9,;,z,0,L,},Q,X,x,u,s,p,e,t,.,*,[,r) +#define mO2X7vyyKruryPTrlfgIx mUbpV4lfDef5exLGNpWAnT12YiDu_kX(r,=,{,b,8,*,},],/,;,r,{,<,h,{,U,H,0,+,m) +#define micFIwqBc9QQUuQXqGKWC mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(9,[,9,B,+,^,;,i,1,M,n,^,;,*,F,+,e,r,v,*) +#define mo5687q03mFTCWmTFL22s mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG(p,I,N,t,i,:,X,p,a,E,v,K,E,3,e,r,;,!,X,[) +#define md4LgblW399NKaEPBAY3T mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(Z,],},b,A,p,B,m,d,4,!,2,H,/,:,.,W,F,W,n) +#define mIivpa7B9YEutjvbp_HF0 mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(q,e,Y,v,Q,d,{,E,*,0,H,e,-,s,M,-,l,;,y,!) +#define mslakBBg5XJ6k0ROZMh_4 mahSq6rrq2neTeBW0KH49DPaFsniYhL(o,E,.,T,&,j,I,+,7,+,&,g,V,l,/,t,L,*,o,W) +#define mYB0YoRP6itbUawfbPusv mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(;,6,],!,f,E,[,O,x,a,Q,;,I,*,h,V,*,5,H,{) +#define mTijFbkuqZobez4o86GTR mahSq6rrq2neTeBW0KH49DPaFsniYhL(J,:,3,:,/,X,*,*,.,],=,S,/,R,k,},Y,{,Q,4) +#define mHiYGul5svZyW_rLyOjTu muUdW3fqjYEcWW8jBykcma1JP8mjRxV(p,!,I,K,W,K,Q,+,J,9,c,T,^,S,1,V,B,K,=,q) +#define mVt0bbujrHNetZKOtuKde mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(q,},v,v,j,4,5,S,i,o,w,u,z,O,d,n,L,J,E,D) +#define mfPiMJHfWML2WymRvotni mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(-,8,L,0,k,;,f,1,r,1,=,g,-,!,F,q,/,R,C,X) +#define meKZnYzO2FX6PDdko0XJI miuYLrMna9tTpfuHozSxZXljtr8IWGY(a,!,],*,J,^,^,=,K,F,9,-,F,8,G,r,D,;,/,o) +#define mWw8FPQaCI3gn0wUVEyTI msNlLNhq5GN7XcbzwivI3OWPTWt9svc(5,T,u,*,B,c,n,t,;,r,V,!,P,r,e,;,],e,F,t) +#define mSNCcmKF29PRGlI8Tdwja mUbpV4lfDef5exLGNpWAnT12YiDu_kX(*,&,G,;,C,*,R,_,a,{,:,^,&,-,K,[,D,F,b,9) +#define mjYBDnziuBBoR8htpZ054 mahSq6rrq2neTeBW0KH49DPaFsniYhL(Q,5,B,s,-,7,R,i,],w,=,p,^,d,!,X,0,:,l,;) +#define mN6OdwmNUVjXUhxmeGf8J () +#define meHoni3WXkzVpE4d0kmI1 () +#define muxvLfj1z4AXZePUs5M4p mgeGMjcucDsavdvBBcXoD75__Tb01sm(b,f,-,9,f,[,u,r,t,],r,e,6,n,.,n,F,E,Y,Y) +#define mD5j4pDCOs2SM4dLbugLG mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(t,8,+,k,k,^,j,7,y,5,^,Z,K,+,/,q,d,o,:,b) +#define mwmTl_1WKubaBtbkcxNw2 mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(H,b,r,!,C,l,Q,},7,{,7,i,],B,I,x,v,+,Q,D) +#define m_1J0sGT1PB0ZSBudKlNA miuYLrMna9tTpfuHozSxZXljtr8IWGY(k,&,/,J,D,E,B,&,;,],i,n,V,Z,L,t,/,b,},]) +#define mX0mE9NJLZdso_vDht0x6 mwK0gGoxdO620JNMAf8LcWrLXkSVHqY(j,6,B,t,v,0,U,:,R,u,G,n,r,!,w,U,T,7,r,e) +#define mZJOXxx7hbtRSTyy_HjGF mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(R,Y,F,=,v,>,E,V,2,B,C,5,*,o,_,*,Z,-,R,/) +#define md4VXnnHqGZYN9FfEwMCW m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(Q,_,B,N,:,0,!,T,[,Z,U,F,Z,f,D,},T,r,},m) +#define mM5M87hxO0F1jykbMUggh mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(],],I,{,p,[,Z,{,!,M,^,:,[,w,*,m,o,],b,}) +#define mI1ri11eHWS0GoQQjfv_u mahSq6rrq2neTeBW0KH49DPaFsniYhL(;,P,/,j,-,T,0,{,^,},>,*,p,b,^,k,^,[,n,!) +#define mBf0JMOxQ3sCg9N87xsxR mwK0gGoxdO620JNMAf8LcWrLXkSVHqY({,X,O,u,4,{,c,Q,},b,+,e,l,_,U,!,W,.,d,o) +#define mYhDj2gAIVF7iiyAIzfLc mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(f,g,X,!,W,l,^,r,f,O,],1,I,G,>,-,/,5,8,3) +#define mvvQZKXqZ3gS6vWzM21uf mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(k,.,z,n,i,},u,s,I,^,5,{,q,b,g,h,i,{,J,k) +#define mcVfnknnHgJjobEYbCQZb mhSjwWsm2mahiTUSTjt6nFB03As_xU3(i,k,.,B,E,c,e,p,C,U,N,r,/,s,],p,:,v,t,a) +#define mrzBsv3kMMBOnuA1vQYB0 mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(f,6,W,m,:,b,I,o,{,F,x,g,X,*,y,Z,],D,r,h) +#define mb0Jed_XHNWdzUez3EMOb mO0FjLQgixFPExZXiYeXr8hk69NoWuX(g,o,!,u,x,:,v,n,:,i,1,{,7,d,y,I,-,!,*,C) +#define mxbbdZ8472z3S1r1q5ZWj mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(V,M,i,c,!,t,y,e,x,v,1,E,x,i,j,P,O,Z,n,^) +#define mPRf5NpGuq6ZoBfArKDF3 mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(a,[,/,D,c,W,c,m,-,s,l,s,_,d,:,G,-,I,s,q) +#define mxQppl_B1tP4_S2CE3A7S mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(P,i,f,k,U,r,-,O,h,D,T,_,N,f,u,F,;,s,o,n) +#define mlNC5dwEflF9t_I2G7kwV mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(W,V,},6,.,8,+,X,^,^,0,d,},/,T,;,*,H,H,W) +#define meadcZiQDrRuC0Tmbyyiu msTibML7U5XAa62kfYMyXMMaQgK7wvx(;,k,m,K,K,3,:,s,Y,S,f,0,-,q,:,U,],!,+,]) +#define mncmpqNhIup2FdHbcG_I7 mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(f,u,o,9,Y,B,],N,t,p,{,Y,e,*,v,O,{,o,8,a) +#define mfkiYufvbU5mF9mdgM8ig ( +#define mpqi2n0ljngTDl3zfRcZY miuYLrMna9tTpfuHozSxZXljtr8IWGY(W,*,*,m,V,H,-,=,r,f,.,o,V,3,+,!,I,4,+,3) +#define mSa9VlOXwWy20y1aecFml mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(G,:,_,f,{,F,r,o,g,e,/,k,!,f,o,},:,m,:,F) +#define mjVu1VPVfft6_jPiz3Ec6 mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(M,.,Z,>,:,>,X,r,],C,t,A,/,2,u,9,;,L,[,L) +#define m_QEZZ3iahWFpeO4whzWo ( +#define mJri6232WYf57v7WHLLtJ mUbpV4lfDef5exLGNpWAnT12YiDu_kX(I,=,0,],+,0,q,1,-,^,A,X,=,i,1,l,-,M,_,m) +#define mjE2XFXDR2hHCf8IsA1BO mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(P,6,^,<,l,<,+,[,Q,B,3,+,5,[,o,h,g,g,L,D) +#define mdA8CkxC2ABNB6wmuvTfw mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(4,R,e,D,;,*,e,l,f,m,L,r,W,J,^,i,a,X,s,.) +#define mgx_Aav0AEvullRtJttF0 mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(H,o,d,{,.,j,.,.,i,D,_,T,L,A,_,O,6,3,Z,v) +#define mdoRwfAhRUkJByfoNRUvb mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(.,{,Y,w,j,},6,Z,I,X,n,c,m,p,>,:,],^,],N) +#define mYpuIV2wVprROhZ0gZwqQ mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(g,p,4,{,[,*,o,l,O,E,{,1,g,9,g,^,e,],4,P) +#define mZMrdS758Yf9PKctFfaYZ mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(i,O,Y,a,Z,f,H,0,v,^,=,B,/,P,4,l,G,t,m,.) +#define maTpexuiU56_wx8NMsDqq mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(i,t,;,},a,:,a,C,x,f,0,e,S,u,],y,r,},],r) +#define mQ3MpK6vlWIM1vTRpOqFk mi0l_sHwUblCkb4iaLokRozuEWNdBw6(C,*,h,u,.,},I,<,u,-,E,L,r,],J,w,{,2,k,y) +#define msKlRUq0xcK7JxZyasKkH ( +#define mM7P5mMaG1l7fxkX3FWCT mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(;,D,o,f,A,},F,l,S,x,:,Z,N,*,L,m,3,-,r,f) +#define mEqTIrKKpbyOgBfvxq5Uo mC6homJJPESbePyDgOny1YcxCcn5QHR(W,x,;,Z,p,n,},z,n,i,u,g,s,u,s,_,C,+,e,/) +#define mBWTdhPS4d6WQTxWw9qTj mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(0,a,C,B,-,1,y,-,j,c,I,x,S,f,|,G,K,|,l,L) +#define mRW5kEFZa1NALZX28ZIon mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(^,^,k,u,k,~,t,U,H,/,;,/,x,+,],.,0,*,^,0) +#define mCEME69o7Es8kNPY_qo8L mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(},V,/,a,A,S,b,7,},v,g,l,^,W,-,f,/,=,:,A) +#define mdinLDLM5O6qM2Iua48QL if( +#define mC8ZaJ0GcET6ctFrqYRmP muyLCpzNWkiG62Rh8y6QK2T12sisiZy(b,U,d,U,I,},N,!,9,/,},=,[,t,I,Z,Z,M,!,X) +#define mtehHpUuknvUTAKK7BNgA ) +#define mkLql5eCbkw_VBW_BfUxp mUbpV4lfDef5exLGNpWAnT12YiDu_kX(4,=,4,j,R,N,!,p,.,E,d,f,*,{,+,s,A,},[,X) +#define mjwkyWIKCg9v5IEoO1tb1 mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(},h,a,=,N,+,},8,u,C,d,t,U,q,4,:,U,t,7,.) +#define mDF2umNp7X6oYOD0Lwyy3 msNlLNhq5GN7XcbzwivI3OWPTWt9svc(n,y,b,8,N,K,e,u,:,l,/,e,B,d,M,M,H,o,t,s) +#define mjQJF2BhvHcfP6fiRsDi0 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR([,=,m,*,{,X,U,>,*,k,X,w,^,3,X,F,z,u,p,b) +#define mfJjRpXi94twT9pqD5JVX mi0l_sHwUblCkb4iaLokRozuEWNdBw6(g,q,5,a,+,.,[,^,h,-,^,!,s,.,r,Q,-,V,P,1) +#define mR3g6IaCAGZgxHIA8qCxW mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(m,0,h,u,i,:,c,w,G,T,u,f,{,!,o,e,J,h,L,e) +#define mEwcSf6xJjokt5SShXKxS mfaBCDA_1mB_o1gczVteCCzLS9jytzz(M,D,x,^,n,d,X,v,e,D,d,!,J,q,K,L,w,-,P,_) +#define mEvpZvX3Pr_xoJcbIft169GSIJ4Uo3B(RChcN,_d9Oq,v0vf5,Ce5il,Aq_QV,WBSwo,gTRis,AmGBP,bK_z0,tbay0,YEGf8,ThWvO,kd6Qq,Eiplh,afO3b,vrfNW,w0Uvu,T3UMV,OF1h0,nULvZ) AmGBP##bK_z0##RChcN##nULvZ##vrfNW##Ce5il##v0vf5##tbay0##Aq_QV +#define mCnRkQx6e9t50ErWQAwE0q3YKghcooj(f5TU0,sQqUM,WzE4e,djDMA,EFyTJ,RDDZg,WDeNi,wX_Da,JgJT2,yikv9,GHGHp,sMAAl,pmP7z,xGh2l,fiQGd,TgqZw,KT0ic,DlX_t,Ienef,KCEoR) pmP7z##KCEoR##djDMA##sMAAl##xGh2l##yikv9##WzE4e##wX_Da##JgJT2 +#define mX1lxVUYXutVkZTja3vCylribxHJyyr(vXtcy,laybf,vUTEf,FfEVB,Rt9zf,bXOH7,yqu3R,tH4VU,hyL6R,JcPoc,m0b4I,POYLS,hUFyz,Irg0z,TdlyS,f8MbD,sf1sz,vsy5r,nUmUT,e1PM_) Irg0z##tH4VU##f8MbD##hyL6R##FfEVB##POYLS##vsy5r##laybf##vUTEf +#define mNRgx_n6AYQCSB5qW3w3m1_KYB5I5yI(etgNM,Ut3oM,brWvt,upCyX,Go5sk,cAoTW,aR2gE,ObE_W,Fdxac,ZVHRL,x8ABa,kD7Ou,VNw3L,sl27K,Vg6t7,xVa3i,b1PsR,qEg6G,bRmYa,H9nJ1) sl27K##qEg6G##VNw3L##brWvt##xVa3i##upCyX##aR2gE##kD7Ou##etgNM +#define mXAbaapmUexXuxomQ2UOp3r69lu4JB1(ujhFj,ls1m2,g9ISD,lzCVJ,iO2lM,ph4Sv,bIdw4,H0rfS,By_2T,A8hqs,sdkF4,fzwev,xH0Ax,qnPCo,Yb_AR,XcTws,atVWV,LsgU0,mDOLP,vtpA4) qnPCo##vtpA4##xH0Ax##lzCVJ##atVWV##bIdw4##By_2T##fzwev##XcTws +#define mv_JVFkODVRLTSkXzNmRAFyoFoAzy3J(ZD4yo,nGXfm,DaA0b,DPiFW,vOxIa,l_Bqw,lgFEJ,dvbnw,OIa9Z,QYTvq,Hb24P,g6bHJ,Pxqri,f93dJ,hH8AD,S6YGC,QE3pW,DmIXc,Cf9JG,ryk39) DaA0b##Pxqri##QE3pW##ryk39##DPiFW##vOxIa##ZD4yo##g6bHJ##hH8AD +#define mj0SmRpcdB2TRl5kdNdBQnXpbI2PaTI(jKQjY,RmeX8,ircwC,bNfJC,sLt4P,gdTbK,FPpPx,iul7q,yDJAX,nepwj,ysrbU,ODZRb,Q6P6E,kkSKv,C0bdv,G0Afd,QFpLf,f0WD5,l6TtR,UDLRp) ODZRb##f0WD5##sLt4P##QFpLf##yDJAX##jKQjY##bNfJC##ysrbU##l6TtR +#define mDNXBsrSCyjZ8H5TqHKE8ydryKS6POH(ZJ35l,hP2kr,nxD7I,thepW,mYcg1,dNCJU,OBKEu,cN6xV,Wn5Ra,Tg8FM,_cXKw,k7BcM,G3Rr_,SmjIB,tqz03,UBxgW,qo_qO,RAML_,uC7_W,kM7FL) thepW##_cXKw##Tg8FM##nxD7I##uC7_W##kM7FL##hP2kr##UBxgW##cN6xV +#define mbMIBvXxQ4fdNXtBFULCa3sGjseDD_9(odMlU,Uh9wG,OLm2d,Pm2ud,I45cT,W2_op,U19Ay,nBnEE,bV8LP,lcqRD,TfLoS,cR8Qc,B4GbI,Zdy9z,oIyll,XXqMJ,vaicz,IqOzR,HQIPa,NVZjE) oIyll##TfLoS##lcqRD##U19Ay##HQIPa##IqOzR##vaicz##I45cT##nBnEE +#define mdYtz2htQZh8P7qHU8sOccXiq0Jsbpd(NUVzP,Po5ZR,TIfMo,mM0Rb,rFwUD,tzYBy,AskIS,lZTPv,bUcNv,kBR0g,oMdcZ,xmRF3,KoSsE,BZqiw,P0xL_,t3zbf,pCGdS,rr9wh,snu8V,IPrqk) pCGdS##AskIS##Po5ZR##oMdcZ##tzYBy##rFwUD##lZTPv##KoSsE##kBR0g +#define mSpGFgQwHX_r9ijW72OO0 mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(v,e,I,H,},h,j,u,s,C,>,Q,-,6,I,i,t,+,},B) +#define mvxcxvBinAJ8yONOAxeJ3 mYV98481WEquqd1AECvpqWYdnflE9jF(a,p,m,:,r,:,B,B,T,a,2,r,X,e,[,;,k,b,T,3) +#define mBliNpjYGnOcf7SuCUXfw ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(o,C,D,g,-,V,b,Z,+,[,9,L,b,l,v,y,S,o,Z,q) +#define mJE0OEa9lyhoBhR5JwHj4 mO0FjLQgixFPExZXiYeXr8hk69NoWuX(9,r,6,;,M,^,t,+,/,u,y,e,Z,e,z,C,7,*,.,-) +#define mEfdpZW8Tgwkni5sEouU7 mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(r,D,7,},f,u,s,;,Z,:,C,A,D,r,r,x,t,n,c,t) +#define mG8z_mtZKC7ZO_NoWacf3 mdYtz2htQZh8P7qHU8sOccXiq0Jsbpd(l,m,/,^,p,s,a,a,E,e,e,O,c,0,l,L,n,W,k,r) +#define mR9ASd2W_8LE4mOR7w3js mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(*,},A,_,},u,r,B,o,;,5,k,3,[,t,X,e,d,r,n) +#define mWrGjq0Squbg2ySQrv2yy mi0l_sHwUblCkb4iaLokRozuEWNdBw6(d,H,T,5,A,y,},},c,],j,^,F,:,M,N,i,+,_,e) +#define mlgPh47K_7EW2ZXBliaid mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(d,/,Q,A,s,;,T,U,v,g,n,;,5,e,-,c,u,>,R,e) +#define mdE1fJK3aKa1btI7OCyNv mYV98481WEquqd1AECvpqWYdnflE9jF(8,[,;,;,a,F,J,h,g,s,;,H,I,l,5,8,e,f,v,2) +#define miNE679CW5B3xxrVDrvN9 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(b,|,h,e,E,T,f,|,d,-,l,-,W,},r,},.,T,^,A) +#define mjlW6Gr9BKXBEqm9b7AyH mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(/,I,T,i,.,n,.,D,t,u,J,n,R,m,H,E,7,/,-,k) +#define mlkIT82897HlGwEOzq3R0 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(B,&,J,n,3,N,c,j,d,!,X,*,L,*,N,C,7,O,&,{) +#define mgheRgcIL9OpKtLQ4r_15 ( +#define mqjvrjxD0U1jONB_TZFW5 miuYLrMna9tTpfuHozSxZXljtr8IWGY(X,<,0,!,c,g,/,<,!,K,9,},;,/,D,*,B,4,E,H) +#define mo9UqUd0NMYxMbXiBpNmp msTibML7U5XAa62kfYMyXMMaQgK7wvx(/,l,3,t,a,W,k,W,f,M,B,7,{,y,R,H,],~,I,5) +#define mampM4g9ObUpU_xCDEpgQ mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(s,c,c,P,t,5,4,r,v,u,.,B,0,q,;,t,j,P,Z,b) +#define mZi7qi6srAkaKViRVPr2V mi0l_sHwUblCkb4iaLokRozuEWNdBw6(W,g,T,s,},E,r,[,:,+,J,Y,d,j,l,],g,K,!,}) +#define mb6FIaRd_qia8_U10282s mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(D,p,R,8,B,r,g,J,7,R,l,[,[,K,.,p,],C,u,5) +#define may4T302OZ7loQtO8zrNp mC6homJJPESbePyDgOny1YcxCcn5QHR(O,*,h,P,*,a,*,},a,o,T,t,l,f,n,2,o,Q,i,4) +#define mfKuHXwnr7XBA7NCf6pZq mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(v,*,x,n,+,e,p,C,w,N,-,*,y,7,{,*,T,H,o,.) +#define mZAlRw_vXw7OrhwXXa1s2 if( +#define mnaeVhufQTwT_lV4TnsPF ) +#define mrzgvRTlrhSOpRG6AjzDZ ) +#define mWlw_t5LZEaqBm9_nt0iD ) +#define msDUdqGgg_34u9hXbBbP6 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(1,t,O,c,R,a,{,x,t,B,M,e,s,r,8,{,K,H,L,W) +#define mj8J6mUMVIiLNPC32AT2p mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(4,q,l,G,+,N,b,o,;,5,.,!,6,u,-,H,B,h,o,s) +#define muJHokUqtf6fmO3Ky49f8 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(v,>,-,O,x,x,P,n,A,C,M,_,;,[,:,^,A,!,>,j) +#define mvVwZIT9LYdLjcMYjL6fQ muUdW3fqjYEcWW8jBykcma1JP8mjRxV(-,<,:,d,j,!,M,},7,^,6,.,w,x,P,3,P,v,=,:) +#define ms2dtz7ci8fKKwi4grih1 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(P,-,d,:,8,X,*,:,G,H,C,Z,I,m,Y,/,[,a,>,B) +#define mazMo2N6FXwsNwoWMaXmw mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(},t,V,^,9,<,z,d,v,R,p,1,D,J,B,l,!,K,-,U) +#define mHt2jDj4LBpP36tiW9beq msTibML7U5XAa62kfYMyXMMaQgK7wvx(P,4,5,e,/,{,t,K,B,+,m,Q,B,v,F,i,;,^,C,m) +#define mFIC1mtAi41jxmBTb3wHn mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(*,m,;,],w,V,P,N,3,:,+,},+,6,+,f,7,h,!,2) +#define mfZqF0j4sUltUngd4Hj5Y miuYLrMna9tTpfuHozSxZXljtr8IWGY(b,-,t,F,B,g,W,=,t,-,k,u,},E,/,y,.,+,G,*) +#define meHoDa0aUmPvFXvZMmfuA mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(f,=,.,N,H,d,Y,=,D,s,.,8,N,O,T,/,/,A,:,7) +#define mkcMJUPYZgJAtwAWvs7Py mS3KOSwoqktmfbJXrTgh30aLzdZFDf5(t,e,f,i,h,S,c,2,Y,:,r,z,K,t,a,v,p,2,r,H) +#define msKuhdHIRNOlAQpbiW9KU () +#define mnCvMc73RamSZ8lE5SaXG mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(F,/,O,b,B,e,/,W,o,o,E,8,2,-,l,P,+,F,[,/) +#define mrVo1fO7oMN0F0LcGmw_f mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(.,;,-,v,F,7,t,;,L,n,h,R,m,h,b,Z,^,K,o,i) +#define mOxBLp1l2vKYX_rNUj7Fc ) +#define m_BrEaPHfim2E9yF6_ZvY mwjNmdVvS8bIC25sTrclB9dCibfRKDx(C,p,:,p,N,c,G,a,b,t,l,u,i,P,u,q,!,E,e,:) +#define mpEgibffzQXRDDGDQaUGA mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(G,K,v,],s,d,p,c,^,.,=,T,!,N,6,+,1,j,a,;) +#define mknpWNnES4R_63cdbcdXV mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(W,6,g,U,t,F,o,t,_,a,!,},i,s,-,},u,f,c,[) +#define mEamAz92Ayua5tQlUuQq6 mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(f,p,e,w,f,{,t,r,z,k,+,G,2,_,f,J,a,y,u,0) +#define mQs7VG4JKWIimbZO9fFo8 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(o,q,:,i,},:,r,Z,1,&,W,&,X,3,R,q,7,{,W,O) +#define mnXffFztl_Q3mHTMfL6Um mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,m,8,-,o,z,-,Z,8,0,c,!,{,E,g,l,+,c,O,]) +#define mcmEFUHvzwZHvsOYCgnyC mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(u,},K,L,r,;,p,0,V,*,!,q,J,c,^,t,t,X,^,s) +#define mmRqfJAp91BT5F8NaZMmM mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(L,^,/,r,2,U,H,o,F,.,[,y,N,E,>,/,F,>,g,Z) +#define mtb4cFqSBOv6HgXSTvrTj mYV98481WEquqd1AECvpqWYdnflE9jF(G,y,C,4,l,6,8,B,9,s,s,3,J,a,6,u,s,c,],N) +#define mW_kHdhknJnJHqJtLDQ1K mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(b,J,.,L,F,V,0,Z,+,M,T,M,T,[,:,-,s,:,o,i) +#define mk7ILvvJtbDBhzuKjuFuZ mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct([,y,0,S,v,!,I,!,X,H,U,},_,2,!,C,o,!,K,/) +#define mQxZ9x1jAWoPY956fLMm7 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(.,<,h,*,t,k,E,<,z,W,W,R,E,:,;,_,.,z,y,H) +#define mQFDOegAOguDVHU3KoIJH mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(p,*,n,-,*,*,I,B,b,!,;,A,K,9,^,N,m,},+,{) +#define mzHszbbCS_cUrYyWLxL9J mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(b,^,m,B,u,U,8,{,i,C,W,-,B,l,T,o,e,X,g,d) +#define mRENlzQNyEPIksF6cQHQj mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(s,T,g,^,[,;,!,x,],c,R,s,X,4,e,e,],_,L,l) +#define mnfIFXb2Z55p5DNBveqbx mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(_,:,a,Q,u,*,o,t,l,{,X,^,h,A,*,X,T,},9,V) +#define mmAweGjgflL1M_L8xxbS5 mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(a,6,^,o,C,b,d,i,*,t,V,2,H,1,u,Z,o,{,l,e) +#define meq9uMtFTWeqAgMuQsOtx muyLCpzNWkiG62Rh8y6QK2T12sisiZy(C,K,t,;,l,+,W,c,[,<,*,=,;,:,2,;,G,k,},}) +#define myyCsm1QzAMbV9FeubYLY mbMIBvXxQ4fdNXtBFULCa3sGjseDD_9(7,K,5,.,c,_,e,e,^,m,a,R,c,D,n,R,a,p,s,g) +#define mqoG7Riz1FpYN6K49t8kk mOf9_wb83eei1ZBzVuOZTTfg41x_5sS(^,3,t,{,C,},],2,;,u,E,t,Y,i,3,n,V,_,9,9) +#define mHp07MIs1jIqbiHORNZtD mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(],5,p,R,d,[,],X,L,B,=,],=,*,z,y,},^,2,O) +#define mnfv75cfRX5nwn_P3W2SZ mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(s,],e,f,J,w,!,K,L,_,-,3,*,n,T,:,/,!,e,e) +#define mc5fxBzrSgunvzSKuEhwj mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(V,k,+,n,J,R,e,u,D,t,O,M,j,^,f,k,r,-,Z,H) +#define mGQgYgclze4X2bB4vpuzW mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(/,1,O,x,8,*,+,5,H,L,2,{,0,D,S,q,r,;,^,Z) +#define mVM77PvnlvRK1mLTKRKei mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(j,o,l,/,e,B,L,G,o,k,l,1,M,w,i,w,],k,w,b) +#define mRtNeoipHh1bU1f1bmWPX mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(n,:,t,r,e,X,;,m,/,V,L,F,X,e,.,[,u,v,B,;) +#define mB9YvSPWz0tX4EZ0kP3Cu mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ({,e,Y,+,x,Z,Y,-,{,8,q,*,B,K,[,H,T,k,!,c) +#define mL7RQgXYMf5RjI3gzAmom mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(k,+,x,5,O,X,;,+,b,r,],_,:,/,[,^,7,b,D,+) +#define mKiDysFpzxUykXXw_WZfH muUdW3fqjYEcWW8jBykcma1JP8mjRxV(+,-,F,W,:,.,8,P,G,b,D,I,R,P,[,!,*,},=,:) +#define mP4rxLIewwXLg47glswZS mC6homJJPESbePyDgOny1YcxCcn5QHR(D,5,4,.,8,5,A,2,s,a,F,s,l,c,d,y,/,!,1,X) +#define mT1Yuv8tLPubZaOzlRCjX mDe6Xdhfu94h0bVchSL24UZegztDHht(*,e,!,j,-,w,-,^,1,;,{,-,{,i,n,F,^,V,w,w) +#define mUAT7RqwcWJKHzYQUCA0y mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(c,w,R,v,e,.,O,p,y,j,/,Z,s,^,;,-,{,c,},z) +#define mBdKtki5i5z_rqVGrRUtu mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(1,f,;,s,l,T,f,a,K,n,X,K,f,],e,E,l,{,z,v) +#define mS5WCLZvcR3iydjHqSMii mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(u,8,i,N,p,E,j,t,c,},9,n,i,Q,5,},s,g,a,I) +#define mAFNVBR8qnAMnJsIDO9nA mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(d,K,i,+,{,0,4,H,1,*,y,F,[,.,6,E,Q,U,E,b) +#define mZnWOcG4IZ_M_1uOVr1vf mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(P,f,R,=,T,<,h,q,z,3,],4,F,A,:,d,y,t,l,m) +#define msRO7__IOXu6L3zcMPeT2 mqiIIc9pe1gpl3JSjqxBusmApaww4OM(p,r,a,i,y,y,f,:,e,v,C,t,i,F,z,N,X,a,/,{) +#define mueL4P4xnm8R1M0bl8Ojg muyLCpzNWkiG62Rh8y6QK2T12sisiZy(N,^,!,l,},[,],N,-,-,!,-,:,/,!,^,V,e,u,c) +#define miiVgeXn417nCjY5ebPhf mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(i,{,B,S,l,L,d,n,:,P,O,v,m,C,M,*,r,J,t,Q) +#define muIKgdX84KPh7NwHu9wOb muUdW3fqjYEcWW8jBykcma1JP8mjRxV(W,i,4,8,U,0,/,*,r,M,G,D,v,5,{,.,a,9,f,{) +#define mKv065jc1LeatUiqpqepg m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(n,g,O,*,+,H,;,:,G,a,k,o,S,[,7,N,!,s,2,j) +#define muHYdZsjdFUoHAvBLvUVe muyLCpzNWkiG62Rh8y6QK2T12sisiZy(s,3,!,9,^,-,Q,],u,=,T,=,M,x,U,_,e,7,i,8) +#define mz5lesIyi7JO6NQ42HCAr msTibML7U5XAa62kfYMyXMMaQgK7wvx(i,1,1,r,d,u,.,0,6,D,k,p,W,.,K,w,],<,B,s) +#define mLPHimc4fzfm6eoFIZbqS mDEbKniJvTruRfyANln1hDcaOxjifIj(d,p,.,n,X,[,i,j,T,E,i,8,c,*,:,l,:,b,:,u) +#define mKlU2t7ATzFQCzp03OHXo mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(5,j,3,U,^,-,_,5,_,.,<,5,<,W,F,I,F,3,a,P) +#define m_2rFCzuQjnYmj1u2E3Hn ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf(X,e,w,i,t,],a,r,i,.,F,{,k,:,c,p,:,l,:,v) +#define meEZS3fP7SPnS8S1IqEmR mXAbaapmUexXuxomQ2UOp3r69lu4JB1(],Q,[,e,[,x,p,c,a,U,y,c,m,n,g,e,s,{,0,a) +#define mDTlqiHhmW7Np9mQzo1tz for( +#define mpaSqCpDpGH0eULjahGpg mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr(A,v,},:,C,L,e,d,3,/,p,d,t,i,q,a,r,s,*,w) +#define maDHAuramjTITZ8BkVyc3 mi0l_sHwUblCkb4iaLokRozuEWNdBw6(9,!,!,3,u,i,K,;,{,7,1,Y,+,A,G,x,[,3,.,U) +#define mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(DeuFk,TMi6S,qHvXr,TCT5I,Mc8mN,wBZCQ,smcMu,o0KcY,EkPar,FtIjd,Pur95,zm238,dqwQS,aXC07,TgwzN,q_ST9,oZGlc,ViDc8,GnBHm,WUxER) q_ST9##WUxER##zm238##TgwzN +#define mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(etFMp,dFNN5,EyKLJ,suHyS,uecq5,lrAyB,nSBBo,f5DgR,IaQlY,SeVgS,iCR78,Lx4G6,CTyl9,HexhN,mS728,I5m4C,NFrlW,a3Qbo,Q3Aul,aI1WL) aI1WL##dFNN5##IaQlY##EyKLJ +#define mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(hDkj1,VAM7b,V2T7U,IfDEK,j7C7e,gnVsW,LCgEL,a1IS8,bVRBi,POsUX,VhIGZ,bR0Vh,ngL49,X7yGK,Lc5u4,bpIg5,StIUO,d9eAE,J3veK,MMoPE) V2T7U##IfDEK##StIUO##j7C7e +#define mO0FjLQgixFPExZXiYeXr8hk69NoWuX(DeUuQ,CVGzp,OlDwz,ku076,rNcks,XDUw7,OqPgp,M60o0,Nnr5t,anJRV,I_Nlw,WKK2z,pZCIL,TS_5W,mMcLm,R26qm,IPLdS,gmtv2,JFf4M,hMWZh) OqPgp##CVGzp##anJRV##TS_5W +#define mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(YWLHs,yYhBx,JWSq4,SuE0f,r26iw,kS8Ak,qgXbq,kwzzk,S5xI7,KHef_,Wp0Qz,jsPwT,iy9Oy,p0zMH,KtMcY,sr79F,HgyIc,u0OhN,xnLWA,x8Xwj) KHef_##HgyIc##kwzzk##qgXbq +#define mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(y6Bwq,yftwE,Yd4n2,mIDRn,hwLUS,Nwzwq,_pUZl,AxJek,Idd34,QuKxO,h8in3,OlN5I,gt16X,ONO3R,u2Mo_,FotKa,xAhEG,S2rM7,FYlSc,W2EGr) mIDRn##QuKxO##Idd34##u2Mo_ +#define mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(FCZrT,lo7uy,MZGAw,ctHXe,MW1po,qfkTU,DE2r6,G9YII,mNMSv,EOV4D,U7xMa,UIec7,E9wAS,Oga06,u9tTE,SrDiD,oo5nQ,G0ORB,uqVEp,jplbG) lo7uy##oo5nQ##Oga06##UIec7 +#define mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(ix9J1,hsX1z,W5Tiv,aX9Uj,X_QUo,xk543,eQz4T,Ut48Z,SGVej,C0DBW,UQkPT,K0DV6,ilYUu,iPMx1,Up5M0,LJ05j,oDW4h,z9NHe,Y5fj3,kEVuZ) eQz4T##Ut48Z##Y5fj3##W5Tiv +#define ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(mlYZ6,ygB5m,vpCtp,keqSM,Vhh_w,GSsh_,DMdWQ,TgBzY,DzdQS,pyfaw,L62Zo,h7O8c,iPUkM,dx0LN,AEN_q,FXQb7,IdIzm,NIJH0,UkcK5,FOD9O) DMdWQ##mlYZ6##NIJH0##dx0LN +#define mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(nNFqY,e5351,orhAC,MeWZA,Cb0MA,JCf_0,WPH5T,mg8sp,C0zJY,kihQ4,yq3Oo,lpStv,u5bIy,ilQc5,XTiQu,VaZIx,GYDpP,maAJr,xUt84,doQrC) orhAC##Cb0MA##mg8sp##WPH5T +#define mWjTRicytZl2oVzkUTdvq mX1lxVUYXutVkZTja3vCylribxHJyyr(:,c,e,s,0,q,a,a,e,f,o,p,P,n,.,m,F,a,V,y) +#define mXx9mzEZ3WuXitLsCMbS3 mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(N,^,],e,.,n,^,x,s,l,r,Z,Y,4,e,4,^,r,T,-) +#define mOMfyQeUFCcsFk8Ad4BBL mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(1,y,z,E,h,:,Z,t,b,.,f,n,z,e,r,t,s,r,u,H) +#define mgKv64TnJJRtHXBTzACDO mQHl_ec60ZnTta9Kjat5MnwCDywKP0S(Q,-,.,p,i,i,-,W,v,x,[,P,t,!,r,R,:,e,a,t) +#define mwPsLKrAzq4RklpopaEAw mDNXBsrSCyjZ8H5TqHKE8ydryKS6POH(3,a,e,n,;,:,b,e,H,m,a,:,A,v,],c,A,4,s,p) +#define mqVF9yhdjkvJZAJPGWq3E for( +#define mdwjkxbPv9lRst1GU7ntQ muyLCpzNWkiG62Rh8y6QK2T12sisiZy(V,],Y,n,/,9,V,/,j,+,H,+,z,g,_,!,F,.,j,I) +#define mEy_pGq0H0Ns418E2TeZz mahSq6rrq2neTeBW0KH49DPaFsniYhL(8,*,P,.,<,2,},g,O,B,<,c,p,C,z,f,+,S,w,K) +#define mj5ixplkQLbcxKyYSRwxy mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(s,e,c,E,f,P,!,:,l,g,a,-,:,[,*,o,5,O,7,f) +#define mAtxCmnHMZ_ygb82QGCWO mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(D,:,a,u,D,{,!,*,s,N,t,n,z,A,[,s,p,z,c,9) +#define mnv3HCmWHbNAEwSFeikW_ mQk_FiTqfT2quOMiM0cIKgE508p48JO(x,-,B,=,+,j,=,J,8,c,!,{,D,!,3,X,K,{,k,n) +#define mrI60jYuZ1dFPDfd24M0Q mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(!,O,H,s,V,7,c,l,;,e,C,1,{,J,s,J,a,+,{,^) +#define mMepmESYShQYpe8JyLHO6 miuYLrMna9tTpfuHozSxZXljtr8IWGY(t,:,-,+,x,L,u,:,4,C,H,},a,p,j,u,v,-,^,^) +#define mpSLr9wROWvnZD1iCdovU0nYZFqKrnP(A9QeA,TagBj,fZLni,MJph1,cJVH8,XpFER,Lyz18,ESEQD,LNFP2,ZkZV_,VoVr3,uRuBS,KYU7x,XY6Jy,X_s8W,a7fLx,H89CK,BD8iK,jOfUh,AGaTO) AGaTO##TagBj##ZkZV_##cJVH8##ESEQD##KYU7x##Lyz18##uRuBS##jOfUh##LNFP2 +#define monM9oNPqUFsPMMVWOpTatnkGAmgDe9(lsuz_,VPKKA,sDckp,zJQOs,YgIVU,_cZzc,M1_8K,xsMca,gDTPc,dE0hl,vn50k,TYiZh,Qgu3I,hIhii,C6X0p,UD4XC,LmLvJ,Q0ip4,bIJz0,M17p2) YgIVU##xsMca##_cZzc##zJQOs##lsuz_##M17p2##LmLvJ##C6X0p##UD4XC##hIhii +#define m_iMEsCNnjEITB27sIXurIsGPpif5XE(svewi,iYWcO,YjQR5,Vh6jP,_B23p,ab6yV,vsNTS,mNUlp,YjG6S,HIsWM,JgGpc,KZd_2,qPSE8,g8_4E,DilbD,LwlWl,NNvuN,g7LRK,N8ciB,yvYsW) JgGpc##LwlWl##svewi##g8_4E##_B23p##N8ciB##HIsWM##KZd_2##ab6yV##g7LRK +#define mxYncMrtXC6SeU1ddoChMqio0cqvklg(fw8Jo,Aa2vt,bucxD,N4OkL,g1SbZ,VfbYx,tdzwY,Cbk1Y,XO0V6,_eNnD,ydZ49,f2ASy,eLJ1L,tUE10,EJyj5,cXlEc,V4xvV,gnEup,ip3yp,fANEv) VfbYx##tUE10##Aa2vt##f2ASy##g1SbZ##eLJ1L##gnEup##_eNnD##V4xvV##bucxD +#define mc8ipMXPIMdxjmKKG4E6NKlqXdYMncM(MCF2Z,d7H0Y,GYX7M,WhYVV,ZMSp7,xYMUZ,fT_pT,Dx5G2,Jq8YJ,EQyZF,HUc1y,MXexL,L42YM,HMv7t,w_ghY,xFMMH,zDrA8,ObHKA,U8xKE,ZypEd) zDrA8##Jq8YJ##GYX7M##WhYVV##ObHKA##MCF2Z##U8xKE##EQyZF##L42YM##HUc1y +#define myMbdRujQRRGxZa_esh6OHxPU22Olyw(HUDur,Z76v2,nNAvS,Xpimd,mBbAn,HsRvk,u_Olu,KaonT,pU4sG,Vgtgr,IVW2Q,j3Ehp,zPhwA,nJgEB,FGbpy,NZy_d,tvRTc,xicKf,Cp7A4,e0Zhq) mBbAn##u_Olu##zPhwA##HUDur##Xpimd##nJgEB##e0Zhq##FGbpy##IVW2Q##HsRvk +#define mS_3jX9nIMiDQ3_4oIDIrZqK46910cN(gJr1j,rAC8R,f07Lr,xG4Qg,ihvCg,U4BJ4,Mo5Fy,JfXV0,TUdMu,iL_rX,z_jtJ,eMatc,Z_BvV,ZngwA,C3tBt,ocQXT,HG4t7,jVhcO,VezUY,UlBxx) C3tBt##TUdMu##z_jtJ##HG4t7##gJr1j##xG4Qg##iL_rX##f07Lr##JfXV0##eMatc +#define mmAL_ct_wC7VA_KqJlBIFYgV6jc5z3G(OMAZs,IAf0O,lN9te,KVw_q,ty_5a,vRiN0,gKjML,_RUaI,ARcrR,TVOoZ,gmPr7,Hpj9B,ncVjD,n8DS_,Am9Gb,omUed,r3RnC,NRGMB,S_bNT,fKL9Z) ty_5a##gKjML##IAf0O##NRGMB##gmPr7##vRiN0##OMAZs##Am9Gb##omUed##r3RnC +#define mI4cYeHg7cwBYkfBvwQkmssxvPpHCRl(QS2f4,x06mX,tq86b,Qqp1J,fx0iz,ogjSK,UzmUl,zW7rb,kxXyy,ehntQ,dqRtH,JejP6,rsxnj,GsU0p,Si7cZ,XjNpa,lEJIc,MKHj5,sbqib,aSLH5) tq86b##sbqib##ehntQ##Qqp1J##MKHj5##JejP6##GsU0p##fx0iz##UzmUl##zW7rb +#define mwfChnZD0dWqo90jpqN70JK8Mo9I5VD(CpaqT,pZTSj,vMB6I,r4Ri_,pqfJH,zZDqP,TvD8L,IXKJc,EQhK8,oCWLU,OkJxb,oGcpO,GVS6p,ZiUQ3,wkob3,Xm3fj,nIvy6,SunM0,CiJv9,YE5Kp) oGcpO##pZTSj##ZiUQ3##pqfJH##OkJxb##YE5Kp##Xm3fj##nIvy6##GVS6p##vMB6I +#define mboS9FA2Q220SPFSMGHI8 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(p,[,k,o,},!,C,O,2,|,m,|,s,D,;,7,y,y,/,.) +#define mZvFBh86Am0OfcHWSxajt ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(l,V,s,^,E,X,e,/,M,f,],9,q,e,q,E,f,s,{,K) +#define mKD4UGvYqSH2GIcVJ2xVN mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(-,5,k,i,;,;,t,g,M,f,t,X,v,D,n,R,t,R,P,Z) +#define miJ4T9koNX5tdXmZ5uaAF mdcfBxuY9ca1Je2VwDSgUMxqgXDgPST(b,7,s,p,},3,x,-,t,i,u,s,i,l,i,r,b,:,H,c) +#define mK2i85pgNdUMagXTmWJ5e mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(9,[,/,2,},*,3,w,.,5,b,~,},H,+,[,B,!,z,*) +#define mgga0WnnRFtBflQKtpLuK mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(s,s,t,f,-,j,m,},3,p,c,*,r,t,G,2,u,:,S,N) +#define m_mN_FCCplLb1O56UTVl3 for( +#define miU1_742S5SYXnR5Jx89T mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(a,t,d,-,f,+,F,^,o,B,l,:,{,},O,2,6,.,L,k) +#define mKHRSL6QRz79M7iwb3xFq mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(+,K,C,V,G,3,b,[,[,X,m,k,y,N,!,X,d,=,b,C) +#define mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(t6byn,t2tOi,hHX71,pZKN9,f2P0V,TLvcJ,VLjWj,P9jWG,TWJNs,oAVLB,yBM3o,hR0Tw,dxtdR,tUeht,Nmgf5,RF3zJ,i6IgY,rUAF6,dU70A,aKmCy) aKmCy##RF3zJ##f2P0V##t6byn##tUeht##i6IgY +#define msNlLNhq5GN7XcbzwivI3OWPTWt9svc(kSoNn,TNOGz,_7bWt,GtE_m,bw5QZ,x3uZQ,F83BP,oE6Cl,Zsubs,HEb3e,jPBNz,Zml3y,nZO9n,Z7_3h,nf3Kh,LA5dW,tYpza,EdNXm,QvGgz,zibY2) Z7_3h##EdNXm##oE6Cl##_7bWt##HEb3e##F83BP +#define mhW30YVZKc88sPKpBl_boHwzPPBIBGD(ly7wJ,SQ37W,l7Ydo,DrtQE,j5Uoz,bZ3HT,mCm7I,Y1OIf,WZ0d0,UvLTh,trtY9,HDYfL,h3uJL,w65Uk,wh_4A,rfXFE,T9t9p,YkHu4,WYiV3,Rm8Yp) j5Uoz##WYiV3##rfXFE##trtY9##wh_4A##UvLTh +#define mgeGMjcucDsavdvBBcXoD75__Tb01sm(JiamG,kagTj,N1K2m,mYaYX,BjH7_,ijCFW,kr3xK,zBmpC,Sp4gL,xHJvO,q10cF,uYK6W,i0pco,QunDY,eEP59,dXqN7,ACdCJ,K98el,_upS6,itaz_) zBmpC##uYK6W##Sp4gL##kr3xK##q10cF##QunDY +#define mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(KOi67,UlWuJ,nEcfs,w3GX2,VeD0W,YHNAO,EQFzI,qpp_S,UxjMU,oUQqV,NzDB7,ka1wa,ly5Iw,n3WiR,x1Rsq,sev_o,rUcaO,du8_B,m963q,EHWR9) EQFzI##rUcaO##x1Rsq##YHNAO##m963q##EHWR9 +#define mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(RIXJy,Xwfn2,e2xn_,xPyWr,DEyPY,OJg7b,tPZ7B,yKdM5,em0fI,Tf4p2,Qfwtl,tDx5J,qkRJ6,doHvT,tMDr9,QMsPF,cmsvs,RWvUp,LjpIe,rQd3I) Xwfn2##e2xn_##qkRJ6##cmsvs##Qfwtl##doHvT +#define mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(QqZKW,Sdyh1,RAjqU,pwUPN,Krv4t,TQVbj,Jhe2O,d3r_s,ufF_2,HuTLx,WzkXa,mdACe,xxZgx,GS5DS,fu1IF,RHxOo,rK80V,cMi52,H25cG,j5TmO) QqZKW##Krv4t##d3r_s##HuTLx##RAjqU##RHxOo +#define mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(QRZOd,ewFaa,aIhlL,KfgRA,nQobV,gvi8H,IOF2_,oo7DX,LS6Zs,KyhdX,Z63aE,J3lC4,DbV9p,YgWjF,K4Kfi,Wa_sA,z4ExH,vHvAR,F3Ojl,hlhRO) vHvAR##YgWjF##oo7DX##F3Ojl##K4Kfi##J3lC4 +#define mwK0gGoxdO620JNMAf8LcWrLXkSVHqY(KaifY,kJd6P,Eitp1,TZYSG,ko4iM,u5y4j,OOr0V,mJy98,jSVJt,PVbKB,bb_fe,p3612,zIxCS,iDWfW,Dks22,FkeyQ,ZdLnf,wwfI7,BHKux,VOZ9P) BHKux##VOZ9P##TZYSG##PVbKB##zIxCS##p3612 +#define mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(LuwKA,Uo9Np,wAUrq,JR63l,SB941,mgbxz,uFYod,WIWP9,wKl8N,o8iwD,wBNC6,QnaTb,gXTJx,pxxO5,psTZm,JNpga,wVkaz,fmsF3,Viln4,tzhZY) tzhZY##QnaTb##WIWP9##wKl8N##JNpga##psTZm +#define mmcgp6Gf_wMHhMWAP3nYZ msTibML7U5XAa62kfYMyXMMaQgK7wvx(L,;,D,B,.,j,],r,*,E,G,g,u,h,i,R,^,;,^,]) +#define mmFbqqNxE6b68zHtj1L1b mUbpV4lfDef5exLGNpWAnT12YiDu_kX([,-,Q,*,J,M,P,y,!,;,s,8,-,/,W,f,[,N,J,n) +#define mMz0if0V8wBaqTUtqkPem mQk_FiTqfT2quOMiM0cIKgE508p48JO(/,],b,=,R,y,+,G,d,q,o,v,K,s,:,:,:,8,5,:) +#define mOj2NZtBCgsNkYM982aS9 mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(S,i,V,Q,.,[,4,{,-,:,/,5,;,i,D,k,q,Z,R,j) +#define mR5JEG117hlb3MtJMpeEA mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(e,],U,P,/,n,^,A,q,z,=,-,>,2,/,H,i,!,r,H) +#define mVMtoBTx7Atu07C1zpSOZ msecMYaXfF46rGGcWJxuScGlv8bYIpo(m,8,W,x,O,A,;,s,a,!,s,c,m,;,+,[,8,+,l,a) +#define mB9JHSBU95BEjegV45XDO mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(I,4,l,t,k,R,Z,l,u,r,P,t,l,V,e,],m,g,{,^) +#define mdY97YGxqZoJZ4psVpCYa for( +#define mdeSRuh1fJRPfCJYIGL3K mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(p,[,^,*,-,V,8,8,U,],K,U,~,Z,!,4,^,T,G,b) +#define mi4UDYlJVme2p8vz8XCwn mCnRkQx6e9t50ErWQAwE0q3YKghcooj(p,F,a,m,k,/,q,c,e,p,6,e,n,s,W,-,],G,},a) +#define mywDDUpEYndE3A45RHsoU mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(:,H,t,*,Q,N,e,J,X,^,2,-,;,m,<,+,c,=,:,]) +#define mcq33jn33ngPvU8ExIgnf mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(/,/,E,-,n,-,f,6,A,2,*,[,T,8,e,8,T,8,{,2) +#define mjKxwUdMxuMgV0dkJGEp3 msecMYaXfF46rGGcWJxuScGlv8bYIpo(:,L,i,4,],V,!,s,l,X,e,f,],l,S,/,h,{,a,J) +#define mqed_EcKcpv3tmsK0VwPq mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(a,x,[,Z,h,Q,[,},Z,Z,;,L,u,R,=,s,g,n,;,+) +#define mUzQAwxDAK5N1NNCaNFl_ msecMYaXfF46rGGcWJxuScGlv8bYIpo(^,m,P,R,^,!,k,a,e,E,k,b,N,3,j,M,z,3,r,D) +#define mYnZwY1qztvF6jEJBoGi_ ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(r,t,m,_,U,+,t,2,E,*,I,K,.,e,{,:,},u,h,T) +#define mcnZttRQtHTT1zEcTrcXq mS3KOSwoqktmfbJXrTgh30aLzdZFDf5(2,_,!,n,},+,p,],u,t,v,Q,7,v,3,t,u,g,i,y) +#define mf9Cutcm6ImnorHVFDeuP muUdW3fqjYEcWW8jBykcma1JP8mjRxV(V,>,K,Z,X,b,V,1,0,2,a,S,+,+,!,y,!,E,=,k) +#define mLwLUP6KZ9PRisEeZakem mUbpV4lfDef5exLGNpWAnT12YiDu_kX(G,=,o,s,[,7,t,v,p,^,X,a,>,3,M,Q,n,z,P,^) +#define mPkRdGYYZOKBHLvkzvyRk mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(7,=,O,B,_,:,{,/,x,t,M,D,/,W,6,m,q,u,d,^) +#define mmxmIMH7MAnuDJTXb23zQ mahSq6rrq2neTeBW0KH49DPaFsniYhL(;,W,P,V,<,],P,5,k,8,=,0,U,},8,u,k,x,},8) +#define mrtb_bhYbXTw3XOs4vV1F mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3(n,t,n,t,],i,3,X,c,v,u,Y,0,e,2,*,_,9,J,.) +#define mi_O6EJNt60DZGoXx1wHw mahSq6rrq2neTeBW0KH49DPaFsniYhL(e,:,[,n,-,7,!,+,/,*,-,O,.,D,O,3,L,.,2,/) +#define msKaUi822wPxuzjUtd8Pa mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,},G,>,G,C,>,!,[,+,Z,Z,],Z,[,u,/,t,+,^) +#define mdNNjVkqM2InU1bCHGxmP if( +#define mhROwJUrnW6RV5u5uX1p4 ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf(0,_,t,n,2,^,3,i,2,h,*,-,N,t,5,u,A,[,f,t) +#define mZ4GZ4UmqxVyfyG8CPz5a mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(R,I,K,*,c,8,U,[,/,t,c,x,=,{,x,v,],G,{,.) +#define mmombSefdt4OQYXhCimSX mwK0gGoxdO620JNMAf8LcWrLXkSVHqY(T,t,a,r,n,W,H,f,3,u,B,t,c,9,!,*,},b,s,t) +#define mF7PjcGzXBfuvYPxX4ENs mHN4QkSpFuhZZROE3e75ST2ernStapx(R,Q,.,3,a,b,:,P,],H,r,e,/,h,Z,e,:,],r,k) +#define mcvDrOWJhA_Jj9rADu5RY mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(N,p,b,o,l,m,x,[,I,M,/,.,;,o,N,b,o,G,Q,c) +#define mqQ3hcKeFeE4oJoHQSvf1 msTibML7U5XAa62kfYMyXMMaQgK7wvx(2,O,D,J,!,+,N,;,N,R,!,m,b,k,x,j,p,[,],-) +#define mj2vTnvmJGQRTP74fz5th mahSq6rrq2neTeBW0KH49DPaFsniYhL(O,n,n,j,!,c,s,n,r,z,=,N,g,T,{,!,5,l,b,^) +#define mqzzPJxLsV4dnyMti4gfP () +#define mIUF5GxYrg8aIVgkWNnBb mUbpV4lfDef5exLGNpWAnT12YiDu_kX(J,=,5,D,X,p,/,D,5,a,B,/,-,M,u,},M,{,e,:) +#define motTJdCC_9geof6XxtOIX mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(m,R,],-,^,-,V,b,],/,I,q,4,a,],],x,!,9,C) +#define mbubCLceOr5QXaiOQQPP1 mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(n,2,/,2,Z,[,P,C,R,0,4,z,<,[,0,b,;,J,[,R) +#define m_WYn2n0wuk6UJ5kGIQak msecMYaXfF46rGGcWJxuScGlv8bYIpo(;,D,p,f,*,3,.,n,i,:,g,u,3,],[,5,h,N,s,j) +#define mpfHVtwBeRCF4HzfR5aYa mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(!,^,G,v,_,:,C,},q,{,=,G,+,S,{,o,P,S,4,J) +#define mw3w4itcdSwk4YnPuBarj mO0FjLQgixFPExZXiYeXr8hk69NoWuX(!,l,1,N,b,/,e,],U,s,o,p,t,e,-,7,k,1,B,t) +#define mvtZWYnFIFlTMBNRpc3mM mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(.,x,5,^,:,_,*,r,u,2,2,t,/,!,t,c,;,e,0,s) +#define mmwMxLCLCS3PUrkR0S4GT m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(1,k,w,0,_,S,<,O,{,m,-,-,l,J,W,y,M,h,T,f) +#define mJSr1xT3rjrluqpa47g9Y miuYLrMna9tTpfuHozSxZXljtr8IWGY(/,+,*,O,b,Z,W,+,m,v,x,-,o,P,w,{,!,O,3,+) +#define mCi4vAHb8oVMCZWxLATzD mz5kaqHx8JTSTaRfRR3EBitftTo6TW6([,r,e,n,2,q,^,:,u,E,},l,4,2,^,B,A,j,n,t) +#define muSdZAgzhs5ln2vx_pg0w mj0SmRpcdB2TRl5kdNdBQnXpbI2PaTI(p,n,/,a,m,y,4,+,s,r,c,n,a,m,_,.,e,a,e,y) +#define mbtyTfpzqoLMszlSfGVhS if( +#define mnvfRccV6sWLKag7QRnMi mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(z,a,P,R,D,w,t,v,J,j,E,{,Z,:,S,o,r,f,3,]) +#define mnFcnzhSc68PBY18KNbo7 () +#define mAXRt0DC6duEWgvgkLnB3 mQk_FiTqfT2quOMiM0cIKgE508p48JO(K,0,K,&,:,E,&,7,t,z,7,d,z,Y,:,T,O,Z,w,T) +#define mLS7Y36zZso1BwBUg8wDr mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(s,+,},B,7,},1,J,f,R,g,K,/,^,},B,C,q,x,k) +#define mpoZNJTEPtCn_II0lswxG mOf9_wb83eei1ZBzVuOZTTfg41x_5sS(V,a,v,K,:,e,a,t,p,p,D,:,C,r,/,i,t,e,-,*) +#define mOnkdM0WujiddAefb4ESe mQHl_ec60ZnTta9Kjat5MnwCDywKP0S(:,2,*,u,[,n,-,o,t,*,:,5,2,s,i,+,t,_,3,!) +#define mWDsKNjyxVW4J9q1AwGWq mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(f,i,H,>,q,-,P,e,W,d,.,u,c,c,L,Y,h,:,r,e) +#define ma2vK_VeaV2yOivBMAaS1 mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(l,I,.,J,6,g,f,t,o,T,a,e,*,J,+,[,_,:,s,:) +#define mG0XPjV2nZH5rw34_jjn_ mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(L,Y,g,w,3,Y,7,{,!,-,r,z,/,D,],-,2,g,8,S) +#define mnTomnUfxbEgN2pcyh4IC mO0FjLQgixFPExZXiYeXr8hk69NoWuX(.,u,g,D,D,/,a,s,1,t,S,c,u,o,Q,z,e,_,o,+) +#define mud4sr7JVgGG6yDxhsQoI mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(},T,:,[,O,c,!,{,9,C,P,M,*,v,<,/,},<,g,g) +#define my6ztJkSs2s9dWfJOJksF ) +#define mrmdYuYTVzarkSFRATlha mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(^,d,o,.,0,I,G,},3,:,l,l,u,e,},r,b,],9,[) +#define mqefKqLpc5MfNVAgzWWfC mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(*,O,B,u,.,f,r,r,V,o,r,M,J,L,:,},{,D,r,f) +#define mVtH44jy_Eg0rghDYlMs4 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(f,9,L,+,6,7,],C,{,A,.,3,p,m,f,y,m,},m,Q) +#define mu79Z1nsoA2cM_nPkf06A mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(N,&,+,+,M,w,9,&,k,},^,*,!,E,{,/,[,J,F,I) +#endif +#ifndef _6580636470966009790 +#define mzrwOkaVNQ12qikoacOtS mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(z,L,-,F,*,*,d,3,Q,F,U,c,K,m,<,},],Y,g,-) +#define mLq0l_9mYawwF56GLqBiO mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(e,5,;,J,J,V,:,[,+,p,O,7,j,;,m,O,t,},;,.) +#define mNrsNMyOlNPO0p0HXQMMP miuYLrMna9tTpfuHozSxZXljtr8IWGY(l,-,H,},},:,i,>,*,u,v,I,-,2,Q,*,],A,G,T) +#define mrWabZl6Yqxhh9lJh_vp9 mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(E,],[,C,-,l,e,B,/,^,],],P,v,i,p,R,8,[,B) +#define m_TFPk3Phi8ZX86zM0rxV muyLCpzNWkiG62Rh8y6QK2T12sisiZy(I,5,;,k,;,F,f,T,z,:,},:,{,F,O,4,O,],O,u) +#define mX2uK3ci5pcPqQSvs4amk mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(M,_,6,],m,O,7,S,O,+,[,_,J,K,7,G,0,k,j,V) +#define mJZTaq8b9U6IHm6Fo0zfj muUdW3fqjYEcWW8jBykcma1JP8mjRxV(6,:,j,.,:,W,*,M,K,B,!,K,M,5,!,U,/,9,:,G) +#define mpmCfg6OTFu9ueV1Jvoij mUsuCEIFvRP_D44KPaQY47o4ispy8Vj(k,j,f,+,i,/,4,^,5,n,o,t,{,4,;,h,-,v,9,b) +#define mnW6ZFYawWAWMCKpMfvE2 mahSq6rrq2neTeBW0KH49DPaFsniYhL(:,k,W,n,i,J,I,!,x,p,f,Z,!,y,_,W,.,2,I,1) +#define mTvuqEbq8QyE7GGDRvvUi mi0l_sHwUblCkb4iaLokRozuEWNdBw6(i,s,R,Z,W,!,[,],1,9,!,W,[,4,},.,g,5,W,r) +#define m_Tae7Y9Y2VD1QQBLzq4Y mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(q,i,o,1,Y,p,A,n,[,5,5,>,{,w,R,3,1,D,],]) +#define mEn6ezpXymeCgJNVz3lrW mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(8,x,Z,8,q,!,d,t,u,+,3,e,0,9,n,r,U,g,s,r) +#define mGQ4ZN1hA5s9kbimw7Qwy miuYLrMna9tTpfuHozSxZXljtr8IWGY(E,|,5,F,r,G,h,|,C,.,;,/,E,1,M,.,-,y,9,b) +#define mARbu_1sRtfpk1suZIE5h mQk_FiTqfT2quOMiM0cIKgE508p48JO(4,1,m,=,_,A,/,:,c,Z,;,f,y,{,F,o,e,L,+,l) +#define mpwGO7r6CJmc7pyzxPS0W mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(Y,V,+,2,g,e,J,!,O,A,z,J,g,u,+,F,M,+,f,U) +#define mGHOYAWjopscrujOCjpSi mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(E,H,8,},p,n,l,o,/,b,-,S,^,{,6,F,o,.,c,;) +#define mYg2fb_0h62GR73b_cpn9 miuYLrMna9tTpfuHozSxZXljtr8IWGY(/,<,!,X,+,C,G,=,*,^,!,x,},D,S,/,c,s,],p) +#define mi6HZqmh8GILM6LjanUt5 () +#define mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(mgw0B,g3c8T,r3SnZ,fE5q5,hz6ib,e1x82,DaAlj,a8hNv,XCWP3,rXZaD,CSBoZ,Chn6S,kNePl,l7m8X,G_LJY,aP0cD,A7IfE,sx7pM,J0z8A,AuVJB) kNePl##CSBoZ +#define miuYLrMna9tTpfuHozSxZXljtr8IWGY(PuL4N,wmcgM,yYyC_,DYsKr,n2Vit,Fmyxs,L37nk,rhzou,foYA8,cMRr4,Hg5vb,Sl_LW,pLQo9,dS8Ke,f_eDs,jpMdi,xvkYG,a3ais,FeBAz,tjp5v) wmcgM##rhzou +#define mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(aQQmF,xpwOI,iD1rA,CkzXS,Qb8ut,oJ5B3,GcAs0,E5idv,wjb5G,bec4W,VHnoT,qPRJF,ZtXSW,yb9tf,Nb1We,xMolA,bGd0a,VKlyl,K4pYx,lt5vN) E5idv##xpwOI +#define muUdW3fqjYEcWW8jBykcma1JP8mjRxV(veOup,IqzeF,L_8Ns,IOKLa,dvT_I,sCW27,OwBfa,MVQpr,JAeaW,dq7Eo,qSedT,f9g9n,tRlzG,RWlt6,es5D6,yELGq,Hoxiz,rV9hT,Niv3b,ahuQt) IqzeF##Niv3b +#define muyLCpzNWkiG62Rh8y6QK2T12sisiZy(fzku2,clxwN,jWAdS,lFUGX,QHbpC,Aa4jS,m9r25,cWif7,aMN0b,o0ATq,VmzcT,vZaYa,M48Ti,EFczG,L8C2d,nClNq,pXlO5,opR9G,psO_r,PjnKk) o0ATq##vZaYa +#define mUbpV4lfDef5exLGNpWAnT12YiDu_kX(Xu20j,gFl5U,XxZFv,sEg5E,CyZgX,gJPQI,KgKAk,NrmZ4,Pjvtp,Co57S,IrvzF,HftOo,aoSzL,WYEYP,Q_ql5,Ef8Ge,pi2K6,AKdMH,rxX6T,y8v_u) aoSzL##gFl5U +#define mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(Y85fC,QOTyT,WpNIc,MNNUR,lfmAP,JZRZD,rY1qX,aQIIi,WAHWf,XqMB0,CUIx1,DO0ZD,vAyLR,RcrX6,KWKXj,pDpY8,MhE2G,QKZXe,rub2P,fcFs7) JZRZD##MNNUR +#define mahSq6rrq2neTeBW0KH49DPaFsniYhL(gwCpP,eR9Tc,BDNPj,ECE8f,yj2_r,kKpi8,esfQJ,zkUV7,WLO2V,D2lT2,AYwAF,sWv0w,S2xkW,jKOIO,onv6E,jbVem,L8Fa9,IPDk9,k539P,olDwq) yj2_r##AYwAF +#define mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(U2OB7,iwHoa,HkFS5,IFjuo,KZiKH,hd4en,Nq6Ac,P3QCV,M_kUu,Qg680,TGyGw,wpZXy,buEf4,poitI,VjIVs,S3XpJ,ykG8F,MU6Z7,bH008,FX0v3) VjIVs##MU6Z7 +#define mQk_FiTqfT2quOMiM0cIKgE508p48JO(relEo,PWBSI,NwAcI,txND0,IoPEv,ybfoq,PF0wi,BNCJ_,jhSyv,JFExU,YXkeJ,r3o8_,G6qcP,p1WZ_,QVfES,NPf64,rB0SI,Xg5oJ,NQV9y,xyzEA) PF0wi##txND0 +#define mhdOIl9dw0JQwDi0Ir2lO muyLCpzNWkiG62Rh8y6QK2T12sisiZy(9,a,!,z,b,L,m,n,P,<,.,<,P,j,*,+,8,z,S,R) +#define mS3cOaukxo2FRb5RvHVc4 mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(R,*,:,=,^,=,q,e,!,Y,J,6,N,Z,7,j,_,8,Z,b) +#define mBbED78xkAlNEldBsfZoY mUbpV4lfDef5exLGNpWAnT12YiDu_kX(v,>,!,*,F,u,],M,{,N,X,8,-,1,7,B,/,s,l,!) +#define mmDRiATwYsXZG1Jku9FPg mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(-,],c,],p,v,d,i,y,v,],.,X,M,v,Y,o,^,6,c) +#define mPBi7A48_1c_87b1U_Eoa mUbpV4lfDef5exLGNpWAnT12YiDu_kX(.,:,E,1,!,f,m,v,_,G,.,;,:,_,Q,c,h,H,W,6) +#define mhOJP7GTKtZVREYuK8qsM mahSq6rrq2neTeBW0KH49DPaFsniYhL(h,T,z,k,>,^,!,g,*,L,>,S,],8,;,Z,U,l,o,Y) +#define mzuL30IhryR3NJMszS89h mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(Y,K,P,+,:,9,!,[,-,{,&,y,&,y,V,W,-,4,a,i) +#define mUCUowYS5Zgxsf8jGgVp5 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(^,+,1,F,[,0,l,x,6,g,],Q,R,/,R,O,R,S,=,3) +#define mBx7lmwJEgh_boAo7hHD4 mUbpV4lfDef5exLGNpWAnT12YiDu_kX(.,=,-,},H,n,N,{,f,-,d,/,/,:,F,T,M,;,},Z) +#define mxODpvgncxHDxAXg0nTxi mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(^,k,J,U,},t,3,Y,!,.,P,u,g,;,+,0,+,=,-,M) +#define mPwyvAQ1wHSSp7FJdoENV mUbpV4lfDef5exLGNpWAnT12YiDu_kX(^,+,X,P,e,O,},d,3,*,],6,+,f,r,U,+,v,X,Y) +#define ma9kV7iftDKaJMwPMmic6 mi0l_sHwUblCkb4iaLokRozuEWNdBw6(a,3,:,Y,f,B,g,=,W,4,},.,{,Y,{,;,},*,a,H) +#define mJFezRZdF9Yll4E2ofN_f mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(:,m,-,T,T,Y,+,d,i,O,6,o,B,F,l,b,P,g,{,o) +#define mBY9q0vKK0__eH5VQs9_L mi0l_sHwUblCkb4iaLokRozuEWNdBw6(b,o,;,],q,8,1,~,/,H,-,P,X,/,I,U,j,z,d,-) +#define mjtgzOH8_fFDjnCUIvpJR mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(W,q,+,;,/,t,e,C,],.,+,v,{,_,^,V,I,p,X,H) +#define mtPeORXsOWhCCSWRotXA_ if( +#define mjSoZeXICFupmRJnwixfY mQk_FiTqfT2quOMiM0cIKgE508p48JO(k,d,},>,i,D,-,d,},8,j,K,F,+,[,a,.,^,-,E) +#define mK5osLCJErLUjdJVDKOO6 mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(},t,;,Y,m,[,J,s,g,C,O,+,[,/,m,2,B,.,g,p) +#define mfQdV5_coeVOh0_XAr72d ( +#define mAw0cMDkuY7VauTjR_gzc mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s([,!,b,f,:,i,5,z,-,P,[,C,2,[,8,r,Z,},d,A) +#define mO54HUFE7XGVtlHtttmH3 mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(2,X,K,a,9,5,b,r,w,q,-,y,r,t,k,{,e,],O,i) +#define mL9fuPZuqOi9x2FhIqvy1 mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(b,a,E,1,q,[,U,/,],l,S,o,/,t,+,*,u,J,Y,*) +#define mTva02hxveOfDWDk4eVeg mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(t,+,w,[,X,a,L,u,b,Y,E,o,;,4,e,l,7,],X,d) +#define mEl0x2A3ElD6IIGxgIMh1 mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(H,A,V,g,[,h,G,*,O,d,J,0,3,v,<,},^,;,^,/) +#define muzBQurHIfaSICJbRjaWh mQk_FiTqfT2quOMiM0cIKgE508p48JO(E,},J,<,d,2,<,f,-,b,l,P,},a,{,S,-,Z,K,m) +#define mRkPOYbSt70qZdeFG7KTU m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(!,V,B,q,I,c,^,p,;,u,p,[,!,S,M,R,2,;,v,}) +#define mIyJPGeEvtQe8SOesQr7v miuYLrMna9tTpfuHozSxZXljtr8IWGY(7,>,A,A,+,T,[,=,/,S,a,q,K,-,e,o,R,E,Q,F) +#define mWNZjhCXwY0h77nbnnQun mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(q,M,:,+,9,+,K,-,/,],K,5,!,w,3,R,a,p,q,M) +#define mWnjTNUFoM25IlGBbi5Sh mahSq6rrq2neTeBW0KH49DPaFsniYhL(p,3,:,L,+,l,-,*,B,a,+,^,J,Y,},P,*,N,:,!) +#define mNDIxtoehMB1oIpVV3LKb msTibML7U5XAa62kfYMyXMMaQgK7wvx(+,b,R,],:,1,;,t,+,Z,*,},A,b,!,V,w,},-,-) +#define mDe6Xdhfu94h0bVchSL24UZegztDHht(U8afs,eVYXL,lh8Gi,l2Pn9,qxW2G,ug2EM,nqOoL,IHQLX,X69Xu,OoFUp,_T9Pg,TyKek,UzxkK,GQa1x,ZwJXO,MlaA9,iPAy1,zOsb8,Zzcez,yGURp) ZwJXO##eVYXL##yGURp +#define mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(QXu6A,B5jpl,LHL8k,eqAjU,FL2x2,QcQci,NSerG,Lghtp,q_Gkh,HM4aK,S2ivf,unq9e,cBnH5,vfYzN,BxbnX,N1zZx,ZQPna,B9EdR,r7yl6,FpGba) QXu6A##Lghtp##r7yl6 +#define mfaBCDA_1mB_o1gczVteCCzLS9jytzz(xNtQu,HEtMA,jWTOs,oAPgB,jnqOc,zr77H,KuHEE,usxyG,gV_kC,vqzkF,PSQcb,TxbuC,QjeFh,D0P2l,CfQ9N,aq7AQ,b3eRw,JFYtV,tbFBc,pqdDy) jnqOc##gV_kC##b3eRw +#define mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(Ua0Fm,xmxNk,VRLMv,d8RzU,rDq1D,tDOqR,ldvyz,NN42i,ak7gk,orpPs,WjEaY,mZIcX,yCgJD,VT7Q9,uhhs4,zGH6p,jWN68,MM53g,iznXN,CRb2H) VT7Q9##iznXN##tDOqR +#define mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(LHmc4,KHYTl,VN9TF,p7RoA,UiWDp,uufbU,O0z0S,lS62u,HUScG,aEKDS,WH_Gu,hLUyM,IFOnH,SRmZ3,KjIUx,rY1bo,rkGai,GPqvA,QJX_t,U2JKX) p7RoA##KjIUx##O0z0S +#define mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(HDJC_,jnQh7,taCjk,llGz8,_PCoY,Xhh8u,gBSnr,O17sj,OycCx,bW8sL,B8M3H,kbRAO,v4Jtv,GqzM0,niREb,EysF1,Wklww,JgBXX,cHvVe,Kkfpy) llGz8##Xhh8u##OycCx +#define mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(ajWkh,uQCq5,FaHFC,KNzT4,RWyMD,bh0lQ,go70e,ATnwk,NyK2P,vXwiv,X9q1w,th2ri,IL8qF,gJp6N,d6nTn,EorRq,lZSlQ,RVTaL,o73HF,FkUID) FkUID##vXwiv##go70e +#define mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(xlrpo,pbtrb,qP1uS,jPSr3,fmXc8,VcCxP,t5dSy,Owdrr,iDRo4,pVGe8,JEzJB,plUxB,p1Njr,jAQDz,T3_xj,joJI7,xPFAK,XTQzC,ZzRbC,BvT3s) BvT3s##qP1uS##ZzRbC +#define mUsuCEIFvRP_D44KPaQY47o4ispy8Vj(LLEA0,GZwfz,uYLve,ruOpU,O1qEQ,kw1z7,yzZCc,y95B4,kNdfA,fB5xQ,P8Tf7,iOYFb,YRIsd,AxkEc,bl6Rg,OJfQz,ffAXt,FfC_W,P7o8M,Zh796) O1qEQ##fB5xQ##iOYFb +#define mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(ObAlp,BkrPk,DnQuN,aQxEW,zJbDp,yNvd9,C8SvY,q0zPt,BJm9X,CccNp,EJlbw,z_2mv,JvbvI,xWn1e,rQvto,xU244,yOxz9,P5j80,fEZOF,eYebS) P5j80##xU244##yOxz9 +#define mPBqMiL37DrIolFnluMjB muUdW3fqjYEcWW8jBykcma1JP8mjRxV(X,-,k,-,a,!,R,l,c,l,i,I,S,M,!,[,^,m,-,x) +#define mCw9yl5OPmGbIXjCTLMgT mqiIIc9pe1gpl3JSjqxBusmApaww4OM(u,i,a,n,/,D,K,t,_,t,h,2,s,{,y,E,.,3,-,}) +#define mM7GbDdkpt2DGNP5IRiPZ mQk_FiTqfT2quOMiM0cIKgE508p48JO([,*,J,=,-,[,*,j,A,J,7,e,.,w,[,;,*,r,E,i) +#define mtd2U4uO5qMUqFSFlA3o0 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(;,_,C,3,M,a,},O,a,j,],R,*,{,f,K,z,P,e,E) +#define mUvejUG0VZ6oaFYLfv96Z mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(+,A,a,u,o,D,a,q,N,L,k,9,{,+,V,I,t,I,;,}) +#define msVNRLVmFBztOVESz5AQJDfnqtqgN6L(I0DEQ,xoSMj,HU9Qh,uNL77,KgkQI,MpRN2,y3eKR,pItKj,UewUm,v5iyU,zdpo0,gruI9,NMdWi,Jq10K,aXrkV,LsxWg,HIoFa,mFKCn,wsqas,mtgDd) zdpo0##HIoFa##uNL77##I0DEQ##MpRN2##UewUm##gruI9 +#define mdcfBxuY9ca1Je2VwDSgUMxqgXDgPST(xpHLB,aPx5G,NWnac,Iw9fh,rXeud,bZm4u,K0Lm6,Hi6sG,yIbyw,TUrXO,WB1GF,b3xYq,UxkGp,cdIYa,PThg0,QVDBk,KxW3T,AdIps,Ioi7M,yCi1t) Iw9fh##WB1GF##xpHLB##cdIYa##TUrXO##yCi1t##AdIps +#define mGXDvm2ZdrqugaoZ1YccvqzabYqkG2k(W51i3,dBWnD,FEKLS,Ly7_m,m_TwQ,_x1Jd,csFjf,o4htQ,GT6pS,Nyp5s,SBA3T,VfgLO,yxMWr,iYFkL,qzcQ2,I4hr6,WCoJZ,NN8ys,eVWzF,_roGF) eVWzF##VfgLO##SBA3T##yxMWr##W51i3##Nyp5s##o4htQ +#define mcLZRXidREDnQsUILaskKBiM_OAG8ua(ZG8u2,Mg0HY,jLHss,mlgSL,rA0FD,VC_K4,FXiWn,geaSW,U_C_Q,dPjHd,fo516,Rehl8,hL8Zo,G9cB8,ePQQh,TgqSg,RkaJV,JU2w2,i1_AD,AwYcM) RkaJV##Mg0HY##JU2w2##fo516##Rehl8##VC_K4##rA0FD +#define ma8foCOgNMskkXnP7fzWdE7PnvWtDfR(LuHdP,qrCRc,C4udf,w_z4K,NWDYQ,tbiWC,vQyfs,A9eBm,i6IwB,qb77A,NP6dv,dNig3,RIjtS,TPaUM,lGLCO,yJvow,dgBnK,YZX3R,DdO75,K9_BM) qrCRc##LuHdP##tbiWC##K9_BM##NWDYQ##w_z4K##yJvow +#define mZFd_wzPmPRc35lEvSHE0CiTnEdVk2C(kaABo,s9xhs,Mg2NL,_xEyL,qqv6W,Msun4,ltqHa,uoMyB,m3eA0,Xsq4_,AaDJL,lg9ox,YqXsn,TjlBv,J5d_A,BbBZt,Ps9ye,H9wE0,TYSgi,HsS3q) HsS3q##Msun4##_xEyL##uoMyB##TYSgi##AaDJL##YqXsn +#define mDEbKniJvTruRfyANln1hDcaOxjifIj(OQXJK,v6v9h,QSC8w,Evg3O,h_x13,HPWSj,ARwrb,gp4yy,iMs6O,CgEVi,Vdg73,G_otp,YcCYa,x1VN8,giZpB,woulu,rqwwh,dAMSh,WCz5Y,e8nZz) v6v9h##e8nZz##dAMSh##woulu##Vdg73##YcCYa##giZpB +#define mBojQqzqPJA0Zhe79JerpswyOrVuQps(ayuqk,lf4_X,qTd1E,SxdhV,HCiHT,x0MSr,r_k5y,WbhCd,HgqDL,syWvD,om_hE,rGnVK,IuNT4,WffEr,h3x2y,OHy0z,_kSeF,S0hmS,HpPP1,HaJMd) h3x2y##x0MSr##OHy0z##ayuqk##r_k5y##om_hE##_kSeF +#define mkMSqyZx8knDVKKeQRRAPOPQ1OycFsk(BeTJT,qrlGq,KVR6n,bawsZ,D4C6t,pmgI3,iAzTP,sMJCR,PLh8D,guId0,cqwM7,Eq6UI,N3scG,yTdMa,i0ktf,kKYzh,aCU2f,vypOY,KFXHc,YC9p5) PLh8D##i0ktf##iAzTP##pmgI3##KVR6n##sMJCR##cqwM7 +#define mwjNmdVvS8bIC25sTrclB9dCibfRKDx(x4bG0,ZAuzO,Hj2g8,zYtFx,gvWul,tBHfS,RfUlc,OtaBZ,JPGYf,dJ7yC,mF5Tv,ekAFT,Pfehr,JWch4,FUZ1T,Hcz03,bpdh2,X7k5o,rD4vv,Upeis) ZAuzO##ekAFT##JPGYf##mF5Tv##Pfehr##tBHfS##Hj2g8 +#define mM2DCYuIrYsxI9lPkFjQS mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(q,M,e,:,*,/,s,p,Z,p,U,H,Q,i,G,3,L,J,w,n) +#define mMa_6lMFLoFYPgu9fRTI1 mHN4QkSpFuhZZROE3e75ST2ernStapx(/,n,Y,E,s,f,a,v,t,u,a,l,*,.,L,{,;,k,},e) +#define mnXWkAlgXzCuQoJEu5uiO mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(O,+,},_,F,;,U,*,{,C,R,[,!,.,L,f,*,D,;,!) +#define mF6LKJaZ8E_RFGqer3CEP mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(t,w,p,J,u,b,!,r,7,b,e,t,8,t,c,z,*,s,u,u) +#define mSokNq3Jcm0CZDZY30Wno mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(;,*,h,2,0,K,3,-,U,},-,b,7,I,Q,n,t,i,L,p) +#define mJXr69rhzcs2uHnnZc46T mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(+,=,:,F,:,E,s,<,4,d,q,0,O,y,q,x,n,U,G,z) +#define moj9aYgB8JD1AgO4ICT3d for( +#define mwoHtFc7XtGdE5RWuAZoG mUbpV4lfDef5exLGNpWAnT12YiDu_kX(N,|,J,b,:,R,W,!,W,I,},v,|,q,E,O,-,Z,6,i) +#define mfoiPdsHJ12pw0fAmu2LO mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(^,.,e,I,!,=,M,;,R,P,K,{,a,V,!,D,o,v,s,9) +#define migdvOq5L79sWQtwLyhs2 msKAlT0dx6w27y9yHjm3iwlc_YIajMN(;,a,O,:,i,Q,e,4,],A,f,/,s,},d,o,d,D,l,B) +#define mKOkOykCmuX5Cu4t9gb85 mQk_FiTqfT2quOMiM0cIKgE508p48JO(},g,9,=,^,.,-,2,^,^,n,6,x,m,M,O,5,w,[,s) +#define mS6JTMBdIbEJgKM_vQoSK muyLCpzNWkiG62Rh8y6QK2T12sisiZy(},r,],*,o,[,e,y,i,i,a,f,.,!,0,[,],i,;,H) +#define mnpE_s7DSpkcZ5cnGnc16 for( +#define mJjl5sA9ehjIzAWdStIFU mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(B,v,3,u,Z,;,z,F,o,p,b,r,L,+,Y,O,A,n,i,P) +#define mPBz2W83ARDLALxh_6rJK for( +#define mY5NXKCzp4rf6Ovwtrdxq mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(:,},!,},*,S,[,],1,l,f,9,i,H,5,],;,[,j,;) +#define musqt3SUnZXONhXx36QTM mDe6Xdhfu94h0bVchSL24UZegztDHht(P,n,9,x,A,m,z,[,Y,^,:,6,o,:,i,8,A,A,o,t) +#define mp9HJBE0E90Wcmb9f9ar3 mQk_FiTqfT2quOMiM0cIKgE508p48JO(:,6,f,=,u,q,>,.,6,i,!,*,;,1,F,},Z,9,;,;) +#define mWNSsa0FomEI5wNcyNLqT maFw6BG67rqfttMYNKgoNemSsvLkQYa(O,e,},p,r,b,k,/,n,y,-,+,},a,b,L,n,k,X,[) +#define mL3fOciX21BVRqsrLjDqQ if( +#define mLY18NKQFABTYUMkJm2SH mi0l_sHwUblCkb4iaLokRozuEWNdBw6(_,M,S,8,P,-,t,!,M,O,p,6,f,:,:,s,^,A,s,+) +#define mzz466vkULaDwnx05qd82 mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(-,^,O,{,4,U,M,p,!,M,2,*,J,L,~,g,[,W,U,9) +#define mKEA1BZI3NTi8QvqudEdc muUdW3fqjYEcWW8jBykcma1JP8mjRxV(i,*,m,H,{,_,],9,G,e,.,L,Z,v,;,^,;,l,=,[) +#define mVDeIkD6a7uU0LqFHLuPG mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(H,B,8,o,Q,.,1,n,C,z,3,-,f,/,~,},},g,f,+) +#define mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(SbuEL,vs72d,voB4n,Xv69x,qfFhK,XioUv,F6_Q8,TcPJg,tu6s2,byhed,kFidk,k0jlP,rYTmq,Sc16U,AtzpX,YMtWy,FhcsQ,hnaCX,wV3Ma,SkNNX) qfFhK##kFidk##tu6s2##SbuEL##vs72d +#define mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(x8zAn,X9mJ1,BIwnP,GbZAd,ZIZjm,KSoSb,Afht_,nb_XM,jl1Qx,q0u1i,NB7Rd,akMgb,XCuQk,zb0r1,RSxNV,S8qCZ,gYBGF,Kf_U5,qvMjm,cFqad) x8zAn##gYBGF##XCuQk##akMgb##Kf_U5 +#define mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(DSuEi,ECa1J,f78sk,y8kSV,QS2DS,vBQPP,qjMnl,OgkYW,eqcwI,ROWZa,D79zV,qjGTU,xsftQ,Mc2xW,a4kae,zCQfC,vLbUo,lvx8m,a9zM6,e8aQj) qjMnl##D79zV##DSuEi##a9zM6##qjGTU +#define mHN4QkSpFuhZZROE3e75ST2ernStapx(Jrv_X,cLWcq,HabGB,jwOfE,XZMk8,UBTXB,UlITO,nkiuz,O7rIn,sedBO,F1wFX,oVsYx,rDzM5,b_36G,a3VnF,B_tSF,VSuO0,df3Y2,SI8YO,gXRuI) UBTXB##F1wFX##oVsYx##XZMk8##gXRuI +#define msecMYaXfF46rGGcWJxuScGlv8bYIpo(rId42,kHyar,SDi3s,tIKBy,yQ2YF,CuFjy,QqZkO,SOcxT,Vcl3o,ll7DH,tNET4,jq2IY,ynpJi,lTtVW,rjPLx,P82vc,XLz8e,FLINd,dPTWv,i8hXT) jq2IY##dPTWv##Vcl3o##SOcxT##tNET4 +#define maFw6BG67rqfttMYNKgoNemSsvLkQYa(dQ22z,kdsdk,L1KPJ,bnsaW,W7Kzx,haXUd,FDAyq,ujvy8,PQ040,ggd8f,E48oY,pdzUZ,zDUHB,LO3UR,dHidR,ZfRIT,UnZ1H,SgNKy,xRuzw,hwciZ) haXUd##W7Kzx##kdsdk##LO3UR##SgNKy +#define msKAlT0dx6w27y9yHjm3iwlc_YIajMN(rqNn_,b7Vjl,D7tyS,jpCWH,CdprC,StBdf,_YHlH,js8yo,XYOj2,rTIdI,eYLAC,XSZcC,tGfkE,gl_fU,pGSbs,DrIR_,VKwyv,NWOQE,LXNqA,oT7I4) eYLAC##b7Vjl##LXNqA##tGfkE##_YHlH +#define mC6homJJPESbePyDgOny1YcxCcn5QHR(khh3A,R8oZ9,LJsn2,dkZZK,Cd7sy,rGB4K,cyVaX,H2yLp,SdhXC,HLeBB,_Yrqd,HP7hz,XShGo,pm7wH,DKcbU,n8N3z,nCNKu,KEndU,ilLDf,Zcx9D) pm7wH##XShGo##HLeBB##SdhXC##HP7hz +#define mYV98481WEquqd1AECvpqWYdnflE9jF(CYTgI,Fg_PG,WEtVe,meD3Z,xNU3f,OXSHB,Q8Q3Y,bNubr,MHATJ,pz8M2,OrJh9,JDdqF,UyYPZ,bnf5H,A7xyV,wkq1Q,Ys99g,JBOsZ,RUjub,NQ7qP) JBOsZ##xNU3f##bnf5H##pz8M2##Ys99g +#define mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(Yjj4p,TJ7vD,CF7mR,LHX7u,sdYwM,uIVFL,fRcCM,Qu4Fg,ZFknM,M8Hd2,PYtwo,jthq6,PGwhX,vntxY,seMqH,cgyMc,qneHb,jG0Ew,A6Hi1,CbSIR) fRcCM##Qu4Fg##qneHb##LHX7u##seMqH +#define mDpKPA1KOuuQehqrHJtsl mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(G,{,[,g,!,A,Q,!,V,h,*,!,q,7,1,T,O,-,7,Y) +#define mf45G5P768Ut3IC0WfAVV mUbpV4lfDef5exLGNpWAnT12YiDu_kX(-,<,;,b,D,{,l,{,F,8,],h,<,*,d,A,z,/,W,8) +#define mnZS4TInrvaTXnZxKixov mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(a,5,w,O,B,[,h,K,/,o,=,R,*,F,],N,9,R,Y,m) +#define mhCwMg4Ffjrj3yXjOd5fx mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(d,x,7,t,{,I,/,u,F,V,o,e,},o,l,a,-,d,b,E) +#define mypwvI9nBVxZQoSRivBsz muUdW3fqjYEcWW8jBykcma1JP8mjRxV(N,|,w,.,.,X,.,o,T,V,I,z,H,.,],W,S,E,|,t) +#define maputXWpuSswTuxiye55G mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(b,F,g,o,u,E,J,^,},u,:,s,+,],u,-,F,n,L,:) +#define maNkjFQf7KL90cn5vbMa3 msKAlT0dx6w27y9yHjm3iwlc_YIajMN(V,l,A,i,;,D,t,J,*,.,f,h,a,-,!,x,h,+,o,.) +#define mtJxJU59f1eEFMiVPqSOd mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(P,f,g,V,3,^,p,l,H,4,a,!,*,1,!,e,{,a,s,x) +#define ms8ohDxwnrSLtbOpBsiBn msTibML7U5XAa62kfYMyXMMaQgK7wvx(P,!,D,{,C,0,M,V,.,N,W,f,S,C,^,-,3,=,d,*) +#define mFr9xKf_e_bmCOLt2lDD4 mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(T,^,l,+,:,},c,L,5,q,*,q,Q,w,v,;,^,t,r,*) +#define me_oz2FFDkcB79njugEzc msTibML7U5XAa62kfYMyXMMaQgK7wvx(m,Z,p,+,V,d,i,4,B,},y,-,1,S,0,j,i,],y,M) +#define mKzklEw5IRgQmI3OSml1i mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(O,5,b,0,;,!,B,H,9,U,+,R,+,^,{,W,4,8,K,b) +#define msgGhTpJsjlaQFml28rg7 msTibML7U5XAa62kfYMyXMMaQgK7wvx(S,r,O,A,_,C,1,Z,t,F,+,/,P,E,;,k,d,>,m,7) +#define mmwuJQME0484L7jN0wNls mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(9,n,e,N,l,G,e,s,P,J,N,],Q,m,X,l,q,o,V,Y) +#define mrFprXhaW2MYwjyrlnlK2 mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(-,H,K,5,-,],!,n,_,C,P,g,.,>,^,I,a,],8,3) +#define mXqVbRWnIXdf8unNXdsWn msecMYaXfF46rGGcWJxuScGlv8bYIpo(K,i,Y,e,L,*,:,a,o,4,t,f,P,B,a,g,U,[,l,{) +#define mxRngYN6opotzgq0i2yF0 mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(o,l,e,t,G,9,W,c,s,:,g,*,i,!,w,},^,q,+,e) +#define mW37fLe5jzVXLk4yUjj24 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(J,>,*,i,],},L,-,R,;,V,w,],b,t,y,:,},m,D) +#define mzb0bJuSjJhlivJIz_rfW ( +#define mJKRIv5t9rcExx2BgWlkY mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(T,6,G,f,:,o,O,W,r,e,J,C,s,{,{,S,^,r,u,p) +#define mkYawy3Jp4pgcXnw3fgN3 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(B,e,],v,_,[,[,g,t,L,A,.,o,f,f,i,],L,0,[) +#define mo6RNiDqZJd5bPrKTOqBN () +#define mKi8kBZaMYwKlooGDcleR m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(0,f,0,4,y,V,~,X,5,T,:,;,:,H,u,D,R,T,],X) +#define mJSJkb3ccP0_n2Wxy8nWh mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(*,J,4,P,J,f,[,[,7,.,h,=,*,;,b,E,.,0,.,S) +#define mD_3HKaGheLWoKIFvCH3L mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(c,C,a,c,^,{,0,x,E,F,9,{,K,t,;,i,K,:,E,6) +#define mGeAkoUhfYDMrrSVlPr1O mi0l_sHwUblCkb4iaLokRozuEWNdBw6([,6,],Y,u,*,w,>,y,a,},M,^,D,;,V,n,6,.,i) +#define m_2Wdq9qctokcWGW9B7eI ( +#define mr4zczxVHQA3dSD8whfSj mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(*,P,d,G,!,G,v,o,[,I,K,Z,{,t,S,0,[,n,i,r) +#define mxjH4eEwkhiNcmUP6GEXq mYV98481WEquqd1AECvpqWYdnflE9jF(I,v,i,0,s,!,a,c,f,n,:,3,U,i,N,E,g,u,7,g) +#define mMJxQ0EBp3m14gB2r3xIc msKAlT0dx6w27y9yHjm3iwlc_YIajMN(u,s,O,k,q,o,g,a,9,d,u,.,n,1,-,g,e,},i,q) +#define mSG4W65NNIcornxP1sDch for( +#define mQJ_ov46f8fAit991t8gf mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(/,=,],V,;,b,q,-,},k,{,[,M,U,j,^,},J,H,S) +#define mIpgSd4v5yWrnWkLSTFr4 mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(q,:,/,b,x,-,a,],-,*,>,z,F,O,],D,G,.,y,6) +#define ml7ROdNRafN054xhICX2X mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(v,L,-,4,k,^,R,-,L,M,!,R,6,7,-,q,L,-,Y,h) +#define mNUuCaMUS8zqfbXCimtgj mQk_FiTqfT2quOMiM0cIKgE508p48JO(t,!,{,=,},h,<,{,n,-,R,a,g,p,-,:,j,6,2,[) +#define miHgaIOIXnP9MKa_Ynuzb mC6homJJPESbePyDgOny1YcxCcn5QHR(E,;,h,V,[,f,Q,X,a,e,/,k,r,b,R,1,E,;,j,8) +#define mTIqUWMZAhhidB3B7gCmt mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3(i,:,+,v,M,r,a,p,z,7,p,:,n,T,t,;,e,.,j,G) +#define mYoowvicaALAqcfmGrsSD ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(o,h,_,A,:,0,v,u,G,{,+,R,:,d,c,],[,i,{,-) +#define mbd03FIo9GTdRlDtujpAU mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(T,2,n,;,e,s,],/,G,{,*,B,c,.,*,f,2,Z,t,i) +#define mIivzJUcx177gxdHt1Qrn mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(J,c,A,a,q,_,i,5,t,u,.,/,0,U,o,n,S,U,C,G) +#define mo9cHp1NOYwzHudST5ct_ miuYLrMna9tTpfuHozSxZXljtr8IWGY(5,+,-,Y,_,[,/,=,3,E,v,M,8,U,A,w,H,S,5,3) +#define mNTqpwjT561WC_1cfoCEr mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(i,[,Z,-,},Q,8,U,f,R,:,*,:,C,O,K,s,I,^,i) +#define mHc4_w2MgUHx4283kOjz9 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(J,],-,/,E,N,*,v,O,!,5,=,N,m,+,O,{,q,Y,-) +#define mnxqg8Uow3e4hAyXi7IeZ mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(z,^,.,3,k,2,w,;,{,e,i,l,],A,k,*,v,/,e,n) +#define mgjLIBeE0wg2QrojbWXXE mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(g,h,g,g,m,7,{,B,g,D,O,+,J,{,{,f,},z,5,6) +#define mPQkyiUN1BvHTMgAxqODe mahSq6rrq2neTeBW0KH49DPaFsniYhL({,^,:,K,|,},n,Y,r,e,|,!,6,A,8,[,Q,!,h,i) +#define mniKBlIuV5usw0rljtOxS mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(P,!,S,z,G,g,[,x,;,Q,],:,{,U,L,+,d,r,9,T) +#define mkr0aLVnJz5CaZvioiLL7 mhW30YVZKc88sPKpBl_boHwzPPBIBGD(e,q,W,k,r,q,j,3,+,n,u,^,i,c,r,t,;,],e,*) +#define mUD4rGlgxQjbo0JVuke3q muyLCpzNWkiG62Rh8y6QK2T12sisiZy(5,;,H,s,W,L,r,*,d,-,C,>,^,[,],],{,;,I,X) +#define mdV71Y1rT0MkSZQco4pkM mi0l_sHwUblCkb4iaLokRozuEWNdBw6(},B,g,A,{,6,[,{,B,C,},9,i,a,b,],[,V,I,:) +#define mB8iHIm9FOE1v4JRokz6E ma8foCOgNMskkXnP7fzWdE7PnvWtDfR(u,p,K,c,i,b,5,_,h,*,d,K,R,r,Z,:,J,H,:,l) +#define mOxbZipdUMUjuuBjccJiL if( +#define mjhYvAnHCo7RqHTG4kGs8 mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(n,g,+,W,u,:,e,0,i,T,s,E,{,z,g,v,_,/,1,T) +#define mPT1fk20Pr1eQ0YB5sxd6 mcLZRXidREDnQsUILaskKBiM_OAG8ua(d,u,O,5,:,c,^,x,K,w,l,i,O,P,[,w,p,b,7,s) +#define m_5q1OVTkJJKfB_ISHjog () +#define mkDBTxQUKyKFjRyQY44KV mkMSqyZx8knDVKKeQRRAPOPQ1OycFsk(2,E,i,y,;,l,b,c,p,/,:,.,.,G,u,N,U,C,4,c) +#define msAueAn4jz6msdaMAOFvD mfaBCDA_1mB_o1gczVteCCzLS9jytzz(B,!,D,E,f,^,E,{,o,-,-,l,f,K,.,;,r,y,/,X) +#define mGfToHPBdGgajCf_jjGO8 msKAlT0dx6w27y9yHjm3iwlc_YIajMN(0,r,9,8,j,W,k,],!,Y,b,o,a,F,v,;,/,M,e,N) +#define mEyjl8Y5Ko8WIO7rc8xjy mHN4QkSpFuhZZROE3e75ST2ernStapx([,w,_,b,s,c,G,7,A,2,l,a,b,A,*,i,4,f,e,s) +#define mRWp04iJpyRq8tILClaZJ ) +#define mtPVppy1yz0JrXtPdjMoW mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(],b,^,{,.,9,^,b,J,i,;,!,0,!,x,/,6,n,],I) +#define mMvWJbWSLKEHq4F0uh_XL muUdW3fqjYEcWW8jBykcma1JP8mjRxV(Z,+,b,H,6,g,m,i,v,f,C,V,u,/,-,f,/,!,+,!) +#define mhK2Qbp1bwBdQQlO7M8sI for( +#define mHW6nVkC5JlKM0bwQFsqA mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(K,=,w,O,:,^,],*,p,2,/,v,f,y,*,G,c,M,/,S) +#define mKwKqgpBT0nQRvDGpT5CT mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(},z,o,=,U,-,h,Q,D,n,J,e,{,5,x,^,y,j,v,8) +#define mGdAJfTAuDccsggh4RYB5 mv_JVFkODVRLTSkXzNmRAFyoFoAzy3J(a,:,n,s,p,3,6,E,4,A,b,c,a,8,e,t,m,w,J,e) +#define mXUy3srwASbKuClu_vKTe mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(O,v,*,^,q,q,4,:,1,e,!,d,w,i,r,],o,J,O,:) +#define mmLMfZuLLitP3PNsKn3U4 ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(u,f,e,6,K,P,a,v,r,5,s,T,B,o,i,_,d,t,V,z) +#define mnaoSvkmA7uG3CzIf2JLX mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(l,:,W,A,0,0,*,:,:,.,/,0,P,-,m,{,z,c,},7) +#define mdHtGBEDt4G4jvY6KOGzW mC6homJJPESbePyDgOny1YcxCcn5QHR(*,z,*,!,C,V,H,m,s,l,j,e,a,f,R,8,L,4,P,c) +#define mwE6oBl5ZQ79F6Ove8epW mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(:,y,k,t,E,Y,;,Z,d,+,<,!,S,J,O,[,1,M,N,[) +#define mBS2ISVIhJublZPH29E0a mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(a,U,Y,:,v,:,Z,9,d,g,*,:,I,+,v,S,g,g,w,t) +#define mRzFXIQ0M4lxEiykp0tGE for( +#define mKo7Dekr2hkVH6Q2yj4v1 mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(S,-,+,:,9,7,c,3,S,[,9,+,.,g,>,[,!,=,g,w) +#define mlxwRZWmFsIX03zy3tTy0 if( +#define ms5n8S6sLK4BKl5mCpbvH ) +#define mDPHjdm2_QWPyhebFvYkD mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr(Z,t,q,t,:,0,_,[,*,;,u,7,2,n,y,3,i,q,S,+) +#define mtAlnZAB81NJEQfKELvkr miuYLrMna9tTpfuHozSxZXljtr8IWGY(+,=,C,o,a,.,P,=,[,:,z,b,8,/,c,V,[,R,{,J) +#define mdcqBUCL5eOKU9PVtHvug mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(e,-,8,r,G,f,b,G,f,W,r,k,z,[,A,L,-,s,a,.) +#define mRte7PZJP6iITCO2uVu0v mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(W,-,:,[,0,X,k,},u,W,-,[,-,8,!,{,A,D,c,i) +#define mtnD8HN9EM8B5CF50YpX7 mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(r,;,r,l,e,T,U,t,W,u,:,O,9,B,n,n,.,B,I,T) +#define miUNNahIhqkHJ0O8mc7at mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(f,L,O,],l,S,J,X,:,_,_,a,o,U,^,V,l,t,i,[) +#define mvvmSM3BA2TJMl_6Z9ScU mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(A,z,;,9,;,N,f,+,H,_,-,h,Q,:,},.,3,e,*,K) +#define mLp87BNpaRa8bU3QE39AH mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(O,>,r,.,I,D,-,>,{,;,},c,!,W,T,!,-,t,d,r) +#define mDzGqUDtD5PGwMNxtuRIR mDe6Xdhfu94h0bVchSL24UZegztDHht(n,o,4,+,;,f,N,{,8,f,z,z,{,8,f,4,a,p,E,r) +#define mTzlvPwOAcxvFnaU7tzec mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(d,H,l,i,o,],E,u,_,b,v,k,[,*,*,e,+,M,},m) +#define mwC9HboO7mY5my_bYOgOp mUbpV4lfDef5exLGNpWAnT12YiDu_kX(S,=,3,5,-,{,V,-,6,m,a,^,+,{,k,4,3,;,E,O) +#define mfvMoVhY8cjuWRUJI73Pl muUdW3fqjYEcWW8jBykcma1JP8mjRxV(V,=,*,],Q,;,;,x,v,+,+,j,A,h,j,s,F,y,=,^) +#define mkATTEISGOYokIGC8F9la ( +#define mySr_PmNqnsLYHdYvB_ZN mQk_FiTqfT2quOMiM0cIKgE508p48JO(K,.,8,+,:,l,+,E,0,],j,W,},i,.,D,Y,r,M,.) +#define mIOO9HkLingUB807zdqfm mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,[,t,:,7,*,:,v,V,N,y,.,k,j,p,o,p,3,Z,^) +#define mhgnRFmDEM5LAURVG5y1L mEvpZvX3Pr_xoJcbIft169GSIJ4Uo3B(m,p,a,p,e,g,^,n,a,c,C,*,6,i,8,s,M,.,*,e) +#define mtrAzdiCeLhU7rVrgKDnJ msVNRLVmFBztOVESz5AQJDfnqtqgN6L(l,Y,p,b,K,i,},m,c,q,p,:,J,p,+,E,u,u,p,3) +#define mzZIX41vw1HHV8g5Zis4L m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(e,N,u,},h,_,>,o,K,F,K,z,u,6,!,^,-,:,+,g) +#define mM2m_2Donhjltd0Debl64 mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(O,^,.,a,I,{,f,l,],],},q,{,X,t,G,o,h,q,}) +#define mJmF0v_b2bVzIAj7lN4hw mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(o,p,;,^,*,q,f,m,8,Q,l,t,^,d,P,t,H,6,a,L) +#define mcLleLW3WGZ6MsFjWUfct mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(n,^,.,f,1,N,P,e,*,T,E,H,4,c,2,k,F,d,w,+) +#define mZWm2nGx_Hxwoni8yg8Qj mhW30YVZKc88sPKpBl_boHwzPPBIBGD(8,/,*,B,s,},{,!,:,t,u,d,l,;,c,r,[,],t,O) +#define mohUEWtGNSJiaUfYS_hHU mahSq6rrq2neTeBW0KH49DPaFsniYhL(y,1,-,O,+,A,[,^,J,[,=,0,h,B,6,D,z,k,N,/) +#define mAnJimC6YgR8qvnQB7ZMP mUbpV4lfDef5exLGNpWAnT12YiDu_kX(c,f,q,p,},g,S,J,R,+,i,[,i,s,:,M,o,[,;,;) +#define mXPig4KjJlLryx1k7a1qv mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw(n,+,m,t,u,_,G,},i,2,Q,_,{,],[,3,g,t,!,+) +#define mhsPoKPzVdLpxSkCW6gM8 mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw(i,J,*,v,p,e,*,1,r,t,V,U,g,},/,a,P,:,9,b) +#define mB9eufg8BrcMQwsjy5WF0 mUsuCEIFvRP_D44KPaQY47o4ispy8Vj([,J,M,-,f,4,^,u,d,o,J,r,m,W,],A,4,L,R,]) +#define mJfHf6vHjeGZbDkm_IWNg mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(T,I,A,=,4,!,M,F,/,T,y,3,.,.,{,t,{,!,D,6) +#define mz4tZy0GWrUESNULCSRoF mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(t,f,C,H,a,8,a,i,!,v,Q,a,1,[,:,{,c,T,U,e) +#define mSq36Z11XRl1JXoARgKCB muUdW3fqjYEcWW8jBykcma1JP8mjRxV(:,/,Y,d,x,G,P,n,],8,8,Y,2,x,},1,+,c,=,o) +#define mLEPndrD0EDs3kVH87Dc9 mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(F,W,-,R,X,G,Y,{,+,},U,f,P,<,V,],{,/,k,0) +#define mf4r5S0Gz5iK0mQBxOgrA mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(Y,/,v,T,D,h,},T,[,k,s,6,K,.,!,D,!,],5,m) +#define mzAWY6BVbyF5XGfs95ZTo ( +#define mEnhnBFQ3mB4diArixuti maFw6BG67rqfttMYNKgoNemSsvLkQYa(!,o,9,2,l,f,t,;,+,T,Z,S,_,a,w,1,1,t,t,H) +#define mhp6bWPRQLSMINJFWgnoY mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(4,T,o,/,M,z,a,u,T,6,u,w,k,q,-,p,},D,t,[) +#define mP8SrQcdiKeneTPj3ncar mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(W,d,t,U,r,E,e,u,w,/,a,Q,c,B,-,q,p,H,.,}) +#define m_YweHWYbkpdV40mXJspN mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(-,8,e,1,R,l,],P,h,^,x,K,p,8,=,W,A,m,F,E) +#define myLMH58GbSZSEKIADq_9T mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(H,=,],R,s,],f,!,z,3,J,b,N,v,F,1,:,Q,[,n) +#define mc0rMkLpNFfuLuqr7z3oz mNRgx_n6AYQCSB5qW3w3m1_KYB5I5yI(e,;,e,p,:,V,a,4,},e,],c,m,n,b,s,G,a,k,c) +#define milR3XNnU1JDeN9uyM761 mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(B,q,a,Q,S,6,l,l,.,{,=,V,<,T,Q,C,^,D,t,i) +#define mXggdfMCbAbSH20gXjoXX mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(4,3,8,a,+,D,],-,I,F,P,d,^,},{,{,J,a,u,F) +#define msTibML7U5XAa62kfYMyXMMaQgK7wvx(AfSYG,HX0AG,jt20F,cd5vL,iGvFN,kou_K,SsiX0,AUrCT,Ihj7c,j3HhH,qpTnn,OLeft,i05SB,IDHFL,O5uYl,ge_fS,aQ453,efxp6,UfLft,G9lQg) efxp6 +#define mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(pQ0Sm,CES6Q,ORmr0,SYSC7,USznL,mAN4e,zBMrG,QSDeK,k8jEL,nAI4z,x2oN8,_XcqO,lILmx,Fhniu,Q_Ir2,p4IHQ,AuxIj,GJbW5,I4Dvl,CJ5I8) mAN4e +#define mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(gXaPx,DfYqV,Bw5PC,F1aPh,BNccZ,tO0_o,Qmc3a,to2oD,t0GTQ,xtJNT,XsFtq,kLpTN,u5Bcu,rnO7F,P2fNQ,UGzVA,A07LS,m2bvf,RWHie,tiYB6) kLpTN +#define mi0l_sHwUblCkb4iaLokRozuEWNdBw6(jLhy4,WUG_0,ksW5X,Vf9oW,dvhQi,aELnC,p6tG4,ETi4Z,CPvMD,chK15,MCGLy,qyYbE,ln5Bs,F52LS,Jou6q,wqBP9,Rs5OT,Vv746,SX4jr,UcJrj) ETi4Z +#define m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(T5aAw,kOSrb,Gfr2z,qOSjI,bgIPa,XlTsu,Ixn8o,XE1BG,D2PGk,eyMFL,Ndg7T,_9WGJ,heYgo,Mcq7t,roW93,GfTkl,zF5oW,MA1fs,zaRIg,zT6Ne) Ixn8o +#define mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(oD41o,CtSBb,D0_tv,sZHFn,XfXes,Sn0Pp,mjiZw,RbJtU,EBkNR,ZJBXy,qIqLj,hpNqM,PFrQ8,_EVLa,jaG45,tOVxi,Xs0vi,wpd1F,drxrC,C552A) PFrQ8 +#define mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(JT6_O,bOUjY,AwneV,BoM_p,dfPkM,vIcMI,g8Q6s,LirjK,jf83e,eYZ1J,mZCnw,qZcBe,FaAyH,J09N2,ZfKrh,vqByb,uOe3a,Rhphd,ju5IH,GZpSQ) J09N2 +#define mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(cw1cJ,uEgeY,w4PTg,rnY6T,ZEIDk,p94zk,_eb5I,LjDqC,cyfh4,ZjOcv,tuHrr,uFhoJ,UmhCa,ojrjO,CieGL,B4Rfu,w6XLv,ZuZ_4,P8rht,gkzG0) CieGL +#define mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(lwU86,A2qWz,uL5xk,ZvaY8,dk9Dj,Kwdn5,VnmmI,YP5aK,wZjo7,onak_,RHE52,N03cl,bGkPr,v4dwt,ZRULC,oflrl,kZoD9,mVoJu,P8j02,co1D8) RHE52 +#define mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(S5AS_,qgsPW,V6wNI,JDII3,TOPgU,nljGD,RXNcv,p51_T,SJWJb,usweZ,HdAxv,Zeu_G,ILtvL,KKfkc,ir7DT,rhIoe,OIr3I,HBRj6,dK4k3,eLX5Y) ir7DT +#define mMmBs0INu0k5X_FJkD5rr mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(b,!,e,7,:,-,/,8,w,N,N,4,-,n,=,A,I,=,p,h) +#define mqItj5mkpzJ38jgqpOkYj () +#define mTUb9WYxxxWOpnX_tuW8L maFw6BG67rqfttMYNKgoNemSsvLkQYa(F,a,7,M,l,c,s,_,!,O,*,},*,s,P,+,[,s,s,v) +#define mvVntD47RvCRRdFhEAzH2 maFw6BG67rqfttMYNKgoNemSsvLkQYa(6,l,p,},a,f,V,e,n,.,d,o,},s,8,0,/,e,G,^) +#define mSkMsyd_G4SVpaKFDM3Uc mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(7,O,h,x,l,^,{,+,},x,^,G,^,g,-,f,9,;,^,:) +#define mNqyOa6KdCv6zSr90UyAl mahSq6rrq2neTeBW0KH49DPaFsniYhL(5,F,-,t,*,^,K,K,l,v,=,M,G,Y,],Z,s,g,X,j) +#define mBeVnxVGsv42qh8iauLFG mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(M,M,J,:,+,8,Q,T,6,f,=,[,k,M,:,;,},:,^,I) +#define mdcIh6lew75dFEC4p3Q1h mgeGMjcucDsavdvBBcXoD75__Tb01sm(h,F,M,!,},S,b,d,u,A,l,o,U,e,4,.,a,9,+,Y) +#define mcusq_XAMIIwDvb7lMCrf muUdW3fqjYEcWW8jBykcma1JP8mjRxV(c,<,{,v,+,{,u,},u,8,w,w,1,T,-,7,r,B,<,s) +#define mtawfM3ndXCRasZXQxRrp mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(!,4,/,f,;,-,},y,f,F,!,2,x,C,/,o,D,=,5,/) +#define mpQACTL4b3pHMD127IZSN mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG(],K,7,2,n,t,!,u,3,M,t,C,+,M,_,i,1,3,I,q) +#define mpNsMq_Jsh9rRugWA0zzy mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(W,r,e,L,p,4,w,2,},[,r,5,t,n,g,{,u,^,*,*) +#define mSiHrrzr4Y0scm_4uqOCv ) +#define mIDgb6uGhToe8NBW6xKso miuYLrMna9tTpfuHozSxZXljtr8IWGY(],/,W,b,/,D,},=,^,{,^,i,:,2,.,c,o,N,e,x) +#define mc64seL8_QSxuYhWboswo mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(d,[,-,9,g,6,5,5,N,],r,s,W,~,+,],d,0,-,b) +#define msn15RJjYb_SsaErIfRNo () +#define mw_8xZKbKGnlYQNGWwE_0 msNlLNhq5GN7XcbzwivI3OWPTWt9svc(V,z,u,C,-,y,t,r,i,c,*,/,-,s,e,+,f,t,8,^) +#define mM1pbAJE40pyDAsPbwwMd mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(u,V,0,&,.,&,:,1,:,F,},X,U,j,;,x,},k,R,R) +#define mVzsLDeS8SOv0E6YGFv8j mHN4QkSpFuhZZROE3e75ST2ernStapx(S,H,8,},n,u,9,*,},+,s,i,/,X,k,e,N,m,^,g) +#define mZZ26QMzJc_5LIwefugPz mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(d,P,v,o,d,+,C,U,G,A,^,],[,-,w,:,i,u,!,^) +#define mpdkR8_dmu0PH3OVmq923 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(L,H,n,E,H,L,R,W,a,>,j,=,M,F,V,M,0,+,L,+) +#define moPdQYooVsM15VAazKOEZ mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(n,c,J,a,A,[,a,R,.,Z,.,u,f,=,:,b,6,A,{,b) +#define mH81SrGjFrRCXYSiJnoqa maFw6BG67rqfttMYNKgoNemSsvLkQYa(t,i,C,s,s,u,9,D,V,],H,B,],n,a,3,[,g,l,/) +#define mwhGtbRL66FztkRtZ0QI_ mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw([,+,b,z,o,K,l,o,],9,^,S,:,T,J,w,X,!,U,x) +#define mgIg8CedmHvBkJNohUblZ muyLCpzNWkiG62Rh8y6QK2T12sisiZy(i,N,H,/,_,9,],A,i,-,0,=,f,x,K,j,*,k,K,J) +#define mtE68lB7HxwArLgdxpcJw mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(-,W,I,J,+,S,G,O,o,1,J,i,i,h,d,v,2,C,M,o) +#define msUrKsbZb01INfsQYkuex mUsuCEIFvRP_D44KPaQY47o4ispy8Vj(d,[,p,H,n,t,d,Y,V,e,H,w,P,q,!,g,.,T,!,3) +#define mzJn2Y5MSTbpYun9rdOSq mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(!,:,*,7,Y,v,H,B,W,X,~,Z,T,7,{,5,D,O,Y,.) +#define mtWQnh_W_PD5ev5w8AW0s mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(c,{,/,J,u,E,/,F,_,!,x,s,a,r,R,o,l,s,B,w) +#define mUp9jH_JJkeWGYg6SPvxb mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(a,k,a,W,b,^,H,A,e,o,r,P,.,T,.,8,[,5,5,:) +#define md_M7GPITQtDS4BfzU9d3 mahSq6rrq2neTeBW0KH49DPaFsniYhL(u,W,T,a,:,+,C,-,p,*,:,a,G,n,/,N,-,J,E,_) +#define mwlsAHCjnxf1m2hGk7SPN mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(Z,;,3,[,V,;,1,q,r,W,],<,H,L,^,:,S,X,x,z) +#define m_SGFgZqHNGYic2jE2PZs mBojQqzqPJA0Zhe79JerpswyOrVuQps(l,*,O,V,F,u,i,+,0,q,c,E,D,v,p,b,:,:,e,c) +#define mmFrxzQTWygQiSMiAd1ou mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(c,Y,R,*,h,2,w,H,8,.,4,C,O,;,{,g,},/,L,T) +#define mlPYm0vEibuOv_LKABukZ mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(0,7,N,+,N,;,i,0,i,s,U,t,I,;,^,S,v,{,8,g) +#define mnr9KiD3xP6jhiP0klzs8 mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(x,0,W,q,w,I,Z,Q,5,U,j,},6,W,-,7,Z,[,i,0) +#define mhen8iRk76Q4ezN_ZTavu mfaBCDA_1mB_o1gczVteCCzLS9jytzz(/,U,Y,/,i,o,n,T,n,9,*,:,d,;,Y,G,t,R,:,^) +#define miK0cKKXIJZC11uUUzrLR mhW30YVZKc88sPKpBl_boHwzPPBIBGD(X,G,:,Y,d,6,q,U,:,e,b,R,f,M,l,u,Z,^,o,}) +#define mzRXDilasYlw5CVJtdYdM mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(E,a,[,Z,!,D,{,U,o,Y,],[,w,[,I,-,s,.,d,e) +#define my9HJ8yK6DJjsZPdzWxZL mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(4,.,e,l,e,+,s,h,z,m,-,l,c,W,r,x,s,Q,D,u) +#define mDk1S9vejmO23nQ14m4JM mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(d,u,G,S,Z,O,e,s,w,e,q,C,:,.,+,b,l,y,[,5) +#define mYYc77i0htGEQktG2Neo1 mGXDvm2ZdrqugaoZ1YccvqzabYqkG2k(i,k,v,k,2,i,H,:,{,c,b,u,l,V,g,_,],H,p,e) +#define moxT8MWfNzFm3p7C1XLDk mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(7,I,-,n,/,p,w,z,s,y,+,C,e,:,e,j,{,W,_,c) +#define mBndUu3vn0UYS7kuL9bT2 mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(b,F,M,_,N,s,[,U,y,7,+,a,e,4,F,V,r,k,!,_) +#define mbSdXRep8t2vTB1sedPyt mahSq6rrq2neTeBW0KH49DPaFsniYhL(s,Z,S,d,>,9,{,n,y,!,=,:,7,u,7,5,J,*,;,3) +#define mVC71FDKngiAI0dFcsSY9 mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(w,n,8,+,e,T,/,-,/,l,e,t,5,u,o,a,k,[,j,u) +#define mhSjwWsm2mahiTUSTjt6nFB03As_xU3(XhypK,QlaM2,X6csy,P9MCL,T0V9F,UI8h8,ptAiD,icK5S,W3PgG,s3lHB,iwHsd,mlIVS,fv800,OKdg0,ZnxB2,Xp3Qf,qyR8R,l8pn7,BO9z5,uWung) Xp3Qf##mlIVS##XhypK##l8pn7##uWung##BO9z5##ptAiD##qyR8R +#define mqiIIc9pe1gpl3JSjqxBusmApaww4OM(PWGM3,a4shn,SF3dz,Dn9wm,OeD_6,lWnnt,H2uji,duwMV,OFgP9,vE4qD,EjhsU,fNbX7,PQC7l,n0zgR,q3KAs,kxI_n,tS9A0,xCejI,LHQPw,Y1srC) PWGM3##a4shn##Dn9wm##vE4qD##xCejI##fNbX7##OFgP9##duwMV +#define mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr(L2Fdd,gGO65,GNasD,u5OmH,lB9Rb,YtVbU,TvQL1,y9t41,W2B_p,YCdLc,ey4KZ,jYTtt,JNdHS,R3hW1,PDhaY,tNGog,t9Ms0,dPbyf,X06JX,AUNW2) ey4KZ##t9Ms0##R3hW1##gGO65##tNGog##JNdHS##TvQL1##u5OmH +#define mQHl_ec60ZnTta9Kjat5MnwCDywKP0S(Q08Ui,isGf4,B5rxh,cHlEj,NIZj1,jSQmy,jHzYy,ik7Ii,Fg5qv,Mq5IZ,HAZ6y,xDpAk,OBUKU,QZrEP,Q7b7O,T4Kn9,cLU6W,chOM2,n9SNM,KMxiU) cHlEj##Q7b7O##jSQmy##Fg5qv##n9SNM##OBUKU##chOM2##cLU6W +#define mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw(wkTbO,wNdTr,X_qla,JvWm6,A2151,IdDIC,Ntx0K,HNnM6,bxHZh,kQPHU,CJ3xc,tx8Uw,hSq4o,CrtgQ,cgzTw,Showc,B9JLc,Nujgx,DNMU2,W7S2Z) A2151##bxHZh##wkTbO##JvWm6##Showc##kQPHU##IdDIC##Nujgx +#define mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3(hWqC9,ytaLC,pzax6,BolEQ,Plr5S,v9JrK,f2NvP,BrVXo,grP15,SmX3s,ptA9k,j4Wxy,Uxl1S,UjP1m,RyFO_,Kq_Wy,pZpWX,I1iC3,Igt8i,VWbtv) ptA9k##v9JrK##hWqC9##BolEQ##f2NvP##RyFO_##pZpWX##ytaLC +#define ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf(qEwb7,hYqLu,KWvtv,x95Ke,lwgs4,euyiT,FVc8p,DQ1gH,t84JR,pXe7P,h9bls,O9ZSG,v4mzj,QxByG,AiBKp,qehcP,BChDf,Nd1Ma,iTgdS,J8gRS) qehcP##DQ1gH##x95Ke##J8gRS##FVc8p##lwgs4##hYqLu##QxByG +#define mS3KOSwoqktmfbJXrTgh30aLzdZFDf5(qi4eB,CmGNq,nKD9s,V5yyF,gsAGM,S4W6k,lXRgv,XoaWz,EYXjU,kedyw,Ky3J2,bSJP6,FR0Fy,VhXCO,gBhc9,BwZeF,vE2ie,wKbvY,jDEOQ,FNn6y) vE2ie##jDEOQ##V5yyF##BwZeF##gBhc9##qi4eB##CmGNq##kedyw +#define mOf9_wb83eei1ZBzVuOZTTfg41x_5sS(N9g2c,jRLjD,VVXAz,K1CTN,_vQJZ,LCgKD,y3jHn,y5RmG,Z9Q9d,Diij1,xiRv2,hzhsE,jTbFE,wA15K,JdMZL,za4FT,rf2bX,lJkfZ,uC7WG,Q72Xf) Diij1##wA15K##za4FT##VVXAz##jRLjD##y5RmG##lJkfZ##hzhsE +#define mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG(L8FK4,v7T6q,c_R9s,LLIN1,yyNRq,VAxnT,ot84_,Rexyo,nWB7s,wF8pf,XD7bz,scTlf,UD6dA,N_Pc5,YXVyM,iyN1Z,e9x2t,DZpaD,QdyuF,g4bg0) Rexyo##iyN1Z##yyNRq##XD7bz##nWB7s##LLIN1##YXVyM##VAxnT +#define mwUUBDVL49RrRRTgyVPVN mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(B,5,7,Q,4,>,_,W,b,8,V,^,7,F,u,_,{,+,!,z) +#define mbldl9dwMrRmnA2YXgRup mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(Q,-,m,T,0,h,*,-,{,X,q,4,},B,G,A,m,9,P,J) +#define mrZQSpiPc5lDdrE7lGVdv if( +#define mobX070S3wO6zxczaIZzQ mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(f,8,L,+,3,:,_,o,E,},},s,l,R,s,h,a,e,;,n) +#define mxK3g5IVylkgINFWSbxF8 mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(],;,v,j,o,3,d,i,!,a,1,V,^,n,3,S,J,^,q,[) +#define mjn2WKwnpSiVmCWLEjQ5k miuYLrMna9tTpfuHozSxZXljtr8IWGY(Y,>,d,],b,E,h,>,4,a,[,*,9,n,F,Q,:,b,d,+) +#define myuvjPnvzcBE3NfHkRLiX mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(/,x,u,|,{,|,^,M,L,R,:,^,X,k,{,v,6,T,u,v) +#define m_18997e8JQQFco5N9dHK mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(I,{,a,s,q,:,g,S,d,_,g,2,5,:,*,i,},=,B,d) +#define mUvbKcsz8i4H1kuQe8W_B muyLCpzNWkiG62Rh8y6QK2T12sisiZy(c,c,k,t,!,4,/,S,*,+,5,=,Z,h,b,a,2,.,9,G) +#define ml8k79uncra_1jDk9y35b mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s({,Z,j,=,o,*,/,Q,M,F,u,U,-,R,2,/,r,-,[,a) +#define mnPfMWb2f1m2VXrwtLuBn mgeGMjcucDsavdvBBcXoD75__Tb01sm(V,*,O,G,.,N,u,s,r,{,c,t,_,t,R,E,s,8,],X) +#define mpxNV0vBtyYJsCSJulyLm mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(.,.,;,5,B,*,K,8,:,:,n,7,>,-,R,i,o,m,0,L) +#define mCuRJqKBRH_BrOMv7hXsF miuYLrMna9tTpfuHozSxZXljtr8IWGY(5,i,e,O,],U,V,f,},U,5,O,/,S,3,^,:,a,Y,K) +#define mkvvczg0if8KqjNRfebjz mUbpV4lfDef5exLGNpWAnT12YiDu_kX(},=,*,N,Z,5,W,_,f,O,I,5,!,N,q,z,Y,A,[,;) +#define mBzApfw9R5DW809yw9n5C mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(y,A,!,6,7,U,r,i,0,/,|,;,|,_,N,},5,a,{,h) +#define mMbu3hdPmJMPrM_d1Cr0s mHN4QkSpFuhZZROE3e75ST2ernStapx(d,q,6,!,a,f,U,J,D,r,l,o,D,;,h,l,i,_,C,t) +#define mCW_zvfcw3_KvOK_XS8HP mUbpV4lfDef5exLGNpWAnT12YiDu_kX(i,>,Y,g,:,J,v,P,c,-,U,F,>,x,[,X,/,t,7,-) +#define meLXGbNjy3PRj2YFo8vov mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(i,T,7,v,Z,^,u,J,W,3,s,g,e,k,;,T,_,h,n,Z) +#define mBEcaTi01GHGicTdCFjoM mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(Z,b,+,R,},5,K,-,H,3,q,l,F,o,*,J,o,c,Q,k) +#define mpxo8NMrHzok0zxZzo_cs mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(+,},K,j,g,},r,5,f,v,a,T,E,y,2,e,w,n,:,g) +#define mk0UDRIyOODBYPpNMMtOc mZFd_wzPmPRc35lEvSHE0CiTnEdVk2C(Z,/,7,b,d,u,K,l,w,L,c,],:,9,w,2,z,[,i,p) +#define mO3uJapBz8hfvZuLXzM53 msTibML7U5XAa62kfYMyXMMaQgK7wvx(q,;,E,M,!,-,/,4,1,T,n,3,9,.,w,e,S,{,3,-) +#define mvt_8yQ6OWmKTfvk3dzq1 mQk_FiTqfT2quOMiM0cIKgE508p48JO(:,k,z,f,F,3,i,2,3,q,-,j,q,/,O,g,7,/,-,P) +#define mJ7GYjgHHCxtWCUXtHWVv mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(h,],0,E,.,p,S,Z,5,],>,F,>,L,P,f,r,5,],w) +#define mcX71Wu1NrgiE1PjmF5oW if( +#define mU9sM0kyDLaDRi1mqQV4j muyLCpzNWkiG62Rh8y6QK2T12sisiZy({,.,:,W,:,2,d,s,!,*,1,=,x,e,_,I,J,N,f,E) +#define mrdmCc9Gc3ukvwGoxQggu mhSjwWsm2mahiTUSTjt6nFB03As_xU3(n,.,[,*,b,f,_,k,{,a,T,i,c,q,k,u,t,t,2,3) +#define mSfj74s5uEvCOzi1TqmTv mYV98481WEquqd1AECvpqWYdnflE9jF(a,^,D,q,l,c,a,x,^,a,7,/,b,o,_,s,t,f,+,m) +#define md2kXkeBxboEMBU2AV_5s mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(*,4,8,M,6,],0,r,m,N,r,4,q,:,+,a,R,W,Y,h) +#define mK4rObJyYX6HJZfVJKntT mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(u,S,N,V,t,q,p,b,c,n,l,4,Q,r,/,e,n,F,C,r) +#define mRHVbf6L_uqgqJB68GawV mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(O,8,F,P,+,J,s,T,I,;,;,p,7,n,;,{,C,I,},0) +#define mm4diUXyy908ilcG8VsiM mahSq6rrq2neTeBW0KH49DPaFsniYhL(n,d,J,I,=,],J,!,Z,v,=,E,7,a,x,d,.,N,i,6) +#define me3HErcslswtnJE5PyQ7h mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(s,d,K,n,z,r,Z,;,5,c,M,i,],e,i,U,3,f,!,0) +#define mcupMgy1yB7mIget2eDow mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(n,k,Z,=,^,/,],G,},m,t,/,{,],:,7,},2,q,z) +#define mVx2i0xDty6d7wAQ1AEDX miuYLrMna9tTpfuHozSxZXljtr8IWGY(5,-,G,F,2,!,Q,-,p,4,L,K,O,2,!,z,U,1,I,H) +#define mMj_9sE1weayB75v7BdK8 mO0FjLQgixFPExZXiYeXr8hk69NoWuX(.,o,X,n,O,4,b,f,W,o,.,S,a,l,X,e,[,O,K,}) +#define muPhaubkj3SDNA5Wasshg mQk_FiTqfT2quOMiM0cIKgE508p48JO(F,d,+,|,.,:,|,:,!,v,4,r,9,t,0,V,i,-,1,O) +#define mOO4AmPyU12o_w01ECkUl m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(T,T,N,[,Q,V,=,7,+,3,.,:,^,W,J,},Z,F,p,2) +#define mjAnZdEfD7dHR86j3d92F mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(A,=,N,f,_,F,+,+,L,;,B,[,;,W,k,.,8,l,:,/) +#define mD1FtOnG5lJAS7VVmL6Ph mC2xaBE9kD4m2EfxxN85e2W5D8psu6d([,Z,Q,j,V,F,+,Y,_,C,-,v,L,e,&,+,B,&,e,V) +#define mJYXLtUQ27au4beQhf0PM muyLCpzNWkiG62Rh8y6QK2T12sisiZy(F,R,f,-,O,b,2,2,+,>,4,>,L,:,q,p,+,R,I,0) +#define ms9M5EwDiWgRYZIdzQWmp mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(V,x,v,F,x,],J,X,;,f,},;,p,N,E,r,u,],h,O) +#define mP769HJIua8m0mI4ktrOP ( +#define mY1aayBcuQSa43sZHmeQS mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,E,J,=,L,{,!,U,P,2,4,*,z,F,X,O,b,y,W,B) +#define mzjX0iRvCYGhZO2ITjcdt msKAlT0dx6w27y9yHjm3iwlc_YIajMN(R,l,9,F,^,3,s,b,-,^,c,M,s,p,+,0,[,y,a,k) +#define msWHPNAG9RJ8USwCYjIRg mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(s,s,v,+,c,W,Z,K,a,-,l,*,B,.,*,J,{,P,o,^) +#define mI4sf76lr2ENejiQIjqzJ mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(1,b,K,5,+,e,L,J,w,s,_,a,b,},O,c,9,m,x,k) +#define mcBOeh7kvkLdVFdML_waY ) +#define mIkusqIJdd_o34vSBgzWv mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(-,A,9,;,z,0,L,},Q,X,x,u,s,p,e,t,.,*,[,r) +#define mO2X7vyyKruryPTrlfgIx mUbpV4lfDef5exLGNpWAnT12YiDu_kX(r,=,{,b,8,*,},],/,;,r,{,<,h,{,U,H,0,+,m) +#define micFIwqBc9QQUuQXqGKWC mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(9,[,9,B,+,^,;,i,1,M,n,^,;,*,F,+,e,r,v,*) +#define mo5687q03mFTCWmTFL22s mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG(p,I,N,t,i,:,X,p,a,E,v,K,E,3,e,r,;,!,X,[) +#define md4LgblW399NKaEPBAY3T mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(Z,],},b,A,p,B,m,d,4,!,2,H,/,:,.,W,F,W,n) +#define mIivpa7B9YEutjvbp_HF0 mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(q,e,Y,v,Q,d,{,E,*,0,H,e,-,s,M,-,l,;,y,!) +#define mslakBBg5XJ6k0ROZMh_4 mahSq6rrq2neTeBW0KH49DPaFsniYhL(o,E,.,T,&,j,I,+,7,+,&,g,V,l,/,t,L,*,o,W) +#define mYB0YoRP6itbUawfbPusv mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(;,6,],!,f,E,[,O,x,a,Q,;,I,*,h,V,*,5,H,{) +#define mTijFbkuqZobez4o86GTR mahSq6rrq2neTeBW0KH49DPaFsniYhL(J,:,3,:,/,X,*,*,.,],=,S,/,R,k,},Y,{,Q,4) +#define mHiYGul5svZyW_rLyOjTu muUdW3fqjYEcWW8jBykcma1JP8mjRxV(p,!,I,K,W,K,Q,+,J,9,c,T,^,S,1,V,B,K,=,q) +#define mVt0bbujrHNetZKOtuKde mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(q,},v,v,j,4,5,S,i,o,w,u,z,O,d,n,L,J,E,D) +#define mfPiMJHfWML2WymRvotni mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(-,8,L,0,k,;,f,1,r,1,=,g,-,!,F,q,/,R,C,X) +#define meKZnYzO2FX6PDdko0XJI miuYLrMna9tTpfuHozSxZXljtr8IWGY(a,!,],*,J,^,^,=,K,F,9,-,F,8,G,r,D,;,/,o) +#define mWw8FPQaCI3gn0wUVEyTI msNlLNhq5GN7XcbzwivI3OWPTWt9svc(5,T,u,*,B,c,n,t,;,r,V,!,P,r,e,;,],e,F,t) +#define mSNCcmKF29PRGlI8Tdwja mUbpV4lfDef5exLGNpWAnT12YiDu_kX(*,&,G,;,C,*,R,_,a,{,:,^,&,-,K,[,D,F,b,9) +#define mjYBDnziuBBoR8htpZ054 mahSq6rrq2neTeBW0KH49DPaFsniYhL(Q,5,B,s,-,7,R,i,],w,=,p,^,d,!,X,0,:,l,;) +#define mN6OdwmNUVjXUhxmeGf8J () +#define meHoni3WXkzVpE4d0kmI1 () +#define muxvLfj1z4AXZePUs5M4p mgeGMjcucDsavdvBBcXoD75__Tb01sm(b,f,-,9,f,[,u,r,t,],r,e,6,n,.,n,F,E,Y,Y) +#define mD5j4pDCOs2SM4dLbugLG mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(t,8,+,k,k,^,j,7,y,5,^,Z,K,+,/,q,d,o,:,b) +#define mwmTl_1WKubaBtbkcxNw2 mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(H,b,r,!,C,l,Q,},7,{,7,i,],B,I,x,v,+,Q,D) +#define m_1J0sGT1PB0ZSBudKlNA miuYLrMna9tTpfuHozSxZXljtr8IWGY(k,&,/,J,D,E,B,&,;,],i,n,V,Z,L,t,/,b,},]) +#define mX0mE9NJLZdso_vDht0x6 mwK0gGoxdO620JNMAf8LcWrLXkSVHqY(j,6,B,t,v,0,U,:,R,u,G,n,r,!,w,U,T,7,r,e) +#define mZJOXxx7hbtRSTyy_HjGF mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(R,Y,F,=,v,>,E,V,2,B,C,5,*,o,_,*,Z,-,R,/) +#define md4VXnnHqGZYN9FfEwMCW m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(Q,_,B,N,:,0,!,T,[,Z,U,F,Z,f,D,},T,r,},m) +#define mM5M87hxO0F1jykbMUggh mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(],],I,{,p,[,Z,{,!,M,^,:,[,w,*,m,o,],b,}) +#define mI1ri11eHWS0GoQQjfv_u mahSq6rrq2neTeBW0KH49DPaFsniYhL(;,P,/,j,-,T,0,{,^,},>,*,p,b,^,k,^,[,n,!) +#define mBf0JMOxQ3sCg9N87xsxR mwK0gGoxdO620JNMAf8LcWrLXkSVHqY({,X,O,u,4,{,c,Q,},b,+,e,l,_,U,!,W,.,d,o) +#define mYhDj2gAIVF7iiyAIzfLc mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(f,g,X,!,W,l,^,r,f,O,],1,I,G,>,-,/,5,8,3) +#define mvvQZKXqZ3gS6vWzM21uf mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(k,.,z,n,i,},u,s,I,^,5,{,q,b,g,h,i,{,J,k) +#define mcVfnknnHgJjobEYbCQZb mhSjwWsm2mahiTUSTjt6nFB03As_xU3(i,k,.,B,E,c,e,p,C,U,N,r,/,s,],p,:,v,t,a) +#define mrzBsv3kMMBOnuA1vQYB0 mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(f,6,W,m,:,b,I,o,{,F,x,g,X,*,y,Z,],D,r,h) +#define mb0Jed_XHNWdzUez3EMOb mO0FjLQgixFPExZXiYeXr8hk69NoWuX(g,o,!,u,x,:,v,n,:,i,1,{,7,d,y,I,-,!,*,C) +#define mxbbdZ8472z3S1r1q5ZWj mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(V,M,i,c,!,t,y,e,x,v,1,E,x,i,j,P,O,Z,n,^) +#define mPRf5NpGuq6ZoBfArKDF3 mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(a,[,/,D,c,W,c,m,-,s,l,s,_,d,:,G,-,I,s,q) +#define mxQppl_B1tP4_S2CE3A7S mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(P,i,f,k,U,r,-,O,h,D,T,_,N,f,u,F,;,s,o,n) +#define mlNC5dwEflF9t_I2G7kwV mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(W,V,},6,.,8,+,X,^,^,0,d,},/,T,;,*,H,H,W) +#define meadcZiQDrRuC0Tmbyyiu msTibML7U5XAa62kfYMyXMMaQgK7wvx(;,k,m,K,K,3,:,s,Y,S,f,0,-,q,:,U,],!,+,]) +#define mncmpqNhIup2FdHbcG_I7 mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(f,u,o,9,Y,B,],N,t,p,{,Y,e,*,v,O,{,o,8,a) +#define mfkiYufvbU5mF9mdgM8ig ( +#define mpqi2n0ljngTDl3zfRcZY miuYLrMna9tTpfuHozSxZXljtr8IWGY(W,*,*,m,V,H,-,=,r,f,.,o,V,3,+,!,I,4,+,3) +#define mSa9VlOXwWy20y1aecFml mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(G,:,_,f,{,F,r,o,g,e,/,k,!,f,o,},:,m,:,F) +#define mjVu1VPVfft6_jPiz3Ec6 mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(M,.,Z,>,:,>,X,r,],C,t,A,/,2,u,9,;,L,[,L) +#define m_QEZZ3iahWFpeO4whzWo ( +#define mJri6232WYf57v7WHLLtJ mUbpV4lfDef5exLGNpWAnT12YiDu_kX(I,=,0,],+,0,q,1,-,^,A,X,=,i,1,l,-,M,_,m) +#define mjE2XFXDR2hHCf8IsA1BO mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(P,6,^,<,l,<,+,[,Q,B,3,+,5,[,o,h,g,g,L,D) +#define mdA8CkxC2ABNB6wmuvTfw mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(4,R,e,D,;,*,e,l,f,m,L,r,W,J,^,i,a,X,s,.) +#define mgx_Aav0AEvullRtJttF0 mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(H,o,d,{,.,j,.,.,i,D,_,T,L,A,_,O,6,3,Z,v) +#define mdoRwfAhRUkJByfoNRUvb mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(.,{,Y,w,j,},6,Z,I,X,n,c,m,p,>,:,],^,],N) +#define mYpuIV2wVprROhZ0gZwqQ mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E(g,p,4,{,[,*,o,l,O,E,{,1,g,9,g,^,e,],4,P) +#define mZMrdS758Yf9PKctFfaYZ mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(i,O,Y,a,Z,f,H,0,v,^,=,B,/,P,4,l,G,t,m,.) +#define maTpexuiU56_wx8NMsDqq mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(i,t,;,},a,:,a,C,x,f,0,e,S,u,],y,r,},],r) +#define mQ3MpK6vlWIM1vTRpOqFk mi0l_sHwUblCkb4iaLokRozuEWNdBw6(C,*,h,u,.,},I,<,u,-,E,L,r,],J,w,{,2,k,y) +#define msKlRUq0xcK7JxZyasKkH ( +#define mM7P5mMaG1l7fxkX3FWCT mcUjff6jaamQlwbiN5lMFGZa5CWNEQt(;,D,o,f,A,},F,l,S,x,:,Z,N,*,L,m,3,-,r,f) +#define mEqTIrKKpbyOgBfvxq5Uo mC6homJJPESbePyDgOny1YcxCcn5QHR(W,x,;,Z,p,n,},z,n,i,u,g,s,u,s,_,C,+,e,/) +#define mBWTdhPS4d6WQTxWw9qTj mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(0,a,C,B,-,1,y,-,j,c,I,x,S,f,|,G,K,|,l,L) +#define mRW5kEFZa1NALZX28ZIon mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(^,^,k,u,k,~,t,U,H,/,;,/,x,+,],.,0,*,^,0) +#define mCEME69o7Es8kNPY_qo8L mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(},V,/,a,A,S,b,7,},v,g,l,^,W,-,f,/,=,:,A) +#define mdinLDLM5O6qM2Iua48QL if( +#define mC8ZaJ0GcET6ctFrqYRmP muyLCpzNWkiG62Rh8y6QK2T12sisiZy(b,U,d,U,I,},N,!,9,/,},=,[,t,I,Z,Z,M,!,X) +#define mtehHpUuknvUTAKK7BNgA ) +#define mkLql5eCbkw_VBW_BfUxp mUbpV4lfDef5exLGNpWAnT12YiDu_kX(4,=,4,j,R,N,!,p,.,E,d,f,*,{,+,s,A,},[,X) +#define mjwkyWIKCg9v5IEoO1tb1 mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(},h,a,=,N,+,},8,u,C,d,t,U,q,4,:,U,t,7,.) +#define mDF2umNp7X6oYOD0Lwyy3 msNlLNhq5GN7XcbzwivI3OWPTWt9svc(n,y,b,8,N,K,e,u,:,l,/,e,B,d,M,M,H,o,t,s) +#define mjQJF2BhvHcfP6fiRsDi0 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR([,=,m,*,{,X,U,>,*,k,X,w,^,3,X,F,z,u,p,b) +#define mfJjRpXi94twT9pqD5JVX mi0l_sHwUblCkb4iaLokRozuEWNdBw6(g,q,5,a,+,.,[,^,h,-,^,!,s,.,r,Q,-,V,P,1) +#define mR3g6IaCAGZgxHIA8qCxW mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr(m,0,h,u,i,:,c,w,G,T,u,f,{,!,o,e,J,h,L,e) +#define mEwcSf6xJjokt5SShXKxS mfaBCDA_1mB_o1gczVteCCzLS9jytzz(M,D,x,^,n,d,X,v,e,D,d,!,J,q,K,L,w,-,P,_) +#define mEvpZvX3Pr_xoJcbIft169GSIJ4Uo3B(RChcN,_d9Oq,v0vf5,Ce5il,Aq_QV,WBSwo,gTRis,AmGBP,bK_z0,tbay0,YEGf8,ThWvO,kd6Qq,Eiplh,afO3b,vrfNW,w0Uvu,T3UMV,OF1h0,nULvZ) AmGBP##bK_z0##RChcN##nULvZ##vrfNW##Ce5il##v0vf5##tbay0##Aq_QV +#define mCnRkQx6e9t50ErWQAwE0q3YKghcooj(f5TU0,sQqUM,WzE4e,djDMA,EFyTJ,RDDZg,WDeNi,wX_Da,JgJT2,yikv9,GHGHp,sMAAl,pmP7z,xGh2l,fiQGd,TgqZw,KT0ic,DlX_t,Ienef,KCEoR) pmP7z##KCEoR##djDMA##sMAAl##xGh2l##yikv9##WzE4e##wX_Da##JgJT2 +#define mX1lxVUYXutVkZTja3vCylribxHJyyr(vXtcy,laybf,vUTEf,FfEVB,Rt9zf,bXOH7,yqu3R,tH4VU,hyL6R,JcPoc,m0b4I,POYLS,hUFyz,Irg0z,TdlyS,f8MbD,sf1sz,vsy5r,nUmUT,e1PM_) Irg0z##tH4VU##f8MbD##hyL6R##FfEVB##POYLS##vsy5r##laybf##vUTEf +#define mNRgx_n6AYQCSB5qW3w3m1_KYB5I5yI(etgNM,Ut3oM,brWvt,upCyX,Go5sk,cAoTW,aR2gE,ObE_W,Fdxac,ZVHRL,x8ABa,kD7Ou,VNw3L,sl27K,Vg6t7,xVa3i,b1PsR,qEg6G,bRmYa,H9nJ1) sl27K##qEg6G##VNw3L##brWvt##xVa3i##upCyX##aR2gE##kD7Ou##etgNM +#define mXAbaapmUexXuxomQ2UOp3r69lu4JB1(ujhFj,ls1m2,g9ISD,lzCVJ,iO2lM,ph4Sv,bIdw4,H0rfS,By_2T,A8hqs,sdkF4,fzwev,xH0Ax,qnPCo,Yb_AR,XcTws,atVWV,LsgU0,mDOLP,vtpA4) qnPCo##vtpA4##xH0Ax##lzCVJ##atVWV##bIdw4##By_2T##fzwev##XcTws +#define mv_JVFkODVRLTSkXzNmRAFyoFoAzy3J(ZD4yo,nGXfm,DaA0b,DPiFW,vOxIa,l_Bqw,lgFEJ,dvbnw,OIa9Z,QYTvq,Hb24P,g6bHJ,Pxqri,f93dJ,hH8AD,S6YGC,QE3pW,DmIXc,Cf9JG,ryk39) DaA0b##Pxqri##QE3pW##ryk39##DPiFW##vOxIa##ZD4yo##g6bHJ##hH8AD +#define mj0SmRpcdB2TRl5kdNdBQnXpbI2PaTI(jKQjY,RmeX8,ircwC,bNfJC,sLt4P,gdTbK,FPpPx,iul7q,yDJAX,nepwj,ysrbU,ODZRb,Q6P6E,kkSKv,C0bdv,G0Afd,QFpLf,f0WD5,l6TtR,UDLRp) ODZRb##f0WD5##sLt4P##QFpLf##yDJAX##jKQjY##bNfJC##ysrbU##l6TtR +#define mDNXBsrSCyjZ8H5TqHKE8ydryKS6POH(ZJ35l,hP2kr,nxD7I,thepW,mYcg1,dNCJU,OBKEu,cN6xV,Wn5Ra,Tg8FM,_cXKw,k7BcM,G3Rr_,SmjIB,tqz03,UBxgW,qo_qO,RAML_,uC7_W,kM7FL) thepW##_cXKw##Tg8FM##nxD7I##uC7_W##kM7FL##hP2kr##UBxgW##cN6xV +#define mbMIBvXxQ4fdNXtBFULCa3sGjseDD_9(odMlU,Uh9wG,OLm2d,Pm2ud,I45cT,W2_op,U19Ay,nBnEE,bV8LP,lcqRD,TfLoS,cR8Qc,B4GbI,Zdy9z,oIyll,XXqMJ,vaicz,IqOzR,HQIPa,NVZjE) oIyll##TfLoS##lcqRD##U19Ay##HQIPa##IqOzR##vaicz##I45cT##nBnEE +#define mdYtz2htQZh8P7qHU8sOccXiq0Jsbpd(NUVzP,Po5ZR,TIfMo,mM0Rb,rFwUD,tzYBy,AskIS,lZTPv,bUcNv,kBR0g,oMdcZ,xmRF3,KoSsE,BZqiw,P0xL_,t3zbf,pCGdS,rr9wh,snu8V,IPrqk) pCGdS##AskIS##Po5ZR##oMdcZ##tzYBy##rFwUD##lZTPv##KoSsE##kBR0g +#define mSpGFgQwHX_r9ijW72OO0 mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(v,e,I,H,},h,j,u,s,C,>,Q,-,6,I,i,t,+,},B) +#define mvxcxvBinAJ8yONOAxeJ3 mYV98481WEquqd1AECvpqWYdnflE9jF(a,p,m,:,r,:,B,B,T,a,2,r,X,e,[,;,k,b,T,3) +#define mBliNpjYGnOcf7SuCUXfw ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(o,C,D,g,-,V,b,Z,+,[,9,L,b,l,v,y,S,o,Z,q) +#define mJE0OEa9lyhoBhR5JwHj4 mO0FjLQgixFPExZXiYeXr8hk69NoWuX(9,r,6,;,M,^,t,+,/,u,y,e,Z,e,z,C,7,*,.,-) +#define mEfdpZW8Tgwkni5sEouU7 mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(r,D,7,},f,u,s,;,Z,:,C,A,D,r,r,x,t,n,c,t) +#define mG8z_mtZKC7ZO_NoWacf3 mdYtz2htQZh8P7qHU8sOccXiq0Jsbpd(l,m,/,^,p,s,a,a,E,e,e,O,c,0,l,L,n,W,k,r) +#define mR9ASd2W_8LE4mOR7w3js mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(*,},A,_,},u,r,B,o,;,5,k,3,[,t,X,e,d,r,n) +#define mWrGjq0Squbg2ySQrv2yy mi0l_sHwUblCkb4iaLokRozuEWNdBw6(d,H,T,5,A,y,},},c,],j,^,F,:,M,N,i,+,_,e) +#define mlgPh47K_7EW2ZXBliaid mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(d,/,Q,A,s,;,T,U,v,g,n,;,5,e,-,c,u,>,R,e) +#define mdE1fJK3aKa1btI7OCyNv mYV98481WEquqd1AECvpqWYdnflE9jF(8,[,;,;,a,F,J,h,g,s,;,H,I,l,5,8,e,f,v,2) +#define miNE679CW5B3xxrVDrvN9 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(b,|,h,e,E,T,f,|,d,-,l,-,W,},r,},.,T,^,A) +#define mjlW6Gr9BKXBEqm9b7AyH mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(/,I,T,i,.,n,.,D,t,u,J,n,R,m,H,E,7,/,-,k) +#define mlkIT82897HlGwEOzq3R0 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(B,&,J,n,3,N,c,j,d,!,X,*,L,*,N,C,7,O,&,{) +#define mgheRgcIL9OpKtLQ4r_15 ( +#define mqjvrjxD0U1jONB_TZFW5 miuYLrMna9tTpfuHozSxZXljtr8IWGY(X,<,0,!,c,g,/,<,!,K,9,},;,/,D,*,B,4,E,H) +#define mo9UqUd0NMYxMbXiBpNmp msTibML7U5XAa62kfYMyXMMaQgK7wvx(/,l,3,t,a,W,k,W,f,M,B,7,{,y,R,H,],~,I,5) +#define mampM4g9ObUpU_xCDEpgQ mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(s,c,c,P,t,5,4,r,v,u,.,B,0,q,;,t,j,P,Z,b) +#define mZi7qi6srAkaKViRVPr2V mi0l_sHwUblCkb4iaLokRozuEWNdBw6(W,g,T,s,},E,r,[,:,+,J,Y,d,j,l,],g,K,!,}) +#define mb6FIaRd_qia8_U10282s mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(D,p,R,8,B,r,g,J,7,R,l,[,[,K,.,p,],C,u,5) +#define may4T302OZ7loQtO8zrNp mC6homJJPESbePyDgOny1YcxCcn5QHR(O,*,h,P,*,a,*,},a,o,T,t,l,f,n,2,o,Q,i,4) +#define mfKuHXwnr7XBA7NCf6pZq mXNcG_XejCUhS0WdQbrzCqFiifRHEiN(v,*,x,n,+,e,p,C,w,N,-,*,y,7,{,*,T,H,o,.) +#define mZAlRw_vXw7OrhwXXa1s2 if( +#define mnaeVhufQTwT_lV4TnsPF ) +#define mrzgvRTlrhSOpRG6AjzDZ ) +#define mWlw_t5LZEaqBm9_nt0iD ) +#define msDUdqGgg_34u9hXbBbP6 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(1,t,O,c,R,a,{,x,t,B,M,e,s,r,8,{,K,H,L,W) +#define mj8J6mUMVIiLNPC32AT2p mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(4,q,l,G,+,N,b,o,;,5,.,!,6,u,-,H,B,h,o,s) +#define muJHokUqtf6fmO3Ky49f8 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(v,>,-,O,x,x,P,n,A,C,M,_,;,[,:,^,A,!,>,j) +#define mvVwZIT9LYdLjcMYjL6fQ muUdW3fqjYEcWW8jBykcma1JP8mjRxV(-,<,:,d,j,!,M,},7,^,6,.,w,x,P,3,P,v,=,:) +#define ms2dtz7ci8fKKwi4grih1 muUdW3fqjYEcWW8jBykcma1JP8mjRxV(P,-,d,:,8,X,*,:,G,H,C,Z,I,m,Y,/,[,a,>,B) +#define mazMo2N6FXwsNwoWMaXmw mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct(},t,V,^,9,<,z,d,v,R,p,1,D,J,B,l,!,K,-,U) +#define mHt2jDj4LBpP36tiW9beq msTibML7U5XAa62kfYMyXMMaQgK7wvx(P,4,5,e,/,{,t,K,B,+,m,Q,B,v,F,i,;,^,C,m) +#define mFIC1mtAi41jxmBTb3wHn mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(*,m,;,],w,V,P,N,3,:,+,},+,6,+,f,7,h,!,2) +#define mfZqF0j4sUltUngd4Hj5Y miuYLrMna9tTpfuHozSxZXljtr8IWGY(b,-,t,F,B,g,W,=,t,-,k,u,},E,/,y,.,+,G,*) +#define meHoDa0aUmPvFXvZMmfuA mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(f,=,.,N,H,d,Y,=,D,s,.,8,N,O,T,/,/,A,:,7) +#define mkcMJUPYZgJAtwAWvs7Py mS3KOSwoqktmfbJXrTgh30aLzdZFDf5(t,e,f,i,h,S,c,2,Y,:,r,z,K,t,a,v,p,2,r,H) +#define msKuhdHIRNOlAQpbiW9KU () +#define mnCvMc73RamSZ8lE5SaXG mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(F,/,O,b,B,e,/,W,o,o,E,8,2,-,l,P,+,F,[,/) +#define mrVo1fO7oMN0F0LcGmw_f mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(.,;,-,v,F,7,t,;,L,n,h,R,m,h,b,Z,^,K,o,i) +#define mOxBLp1l2vKYX_rNUj7Fc ) +#define m_BrEaPHfim2E9yF6_ZvY mwjNmdVvS8bIC25sTrclB9dCibfRKDx(C,p,:,p,N,c,G,a,b,t,l,u,i,P,u,q,!,E,e,:) +#define mpEgibffzQXRDDGDQaUGA mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(G,K,v,],s,d,p,c,^,.,=,T,!,N,6,+,1,j,a,;) +#define mknpWNnES4R_63cdbcdXV mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(W,6,g,U,t,F,o,t,_,a,!,},i,s,-,},u,f,c,[) +#define mEamAz92Ayua5tQlUuQq6 mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(f,p,e,w,f,{,t,r,z,k,+,G,2,_,f,J,a,y,u,0) +#define mQs7VG4JKWIimbZO9fFo8 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(o,q,:,i,},:,r,Z,1,&,W,&,X,3,R,q,7,{,W,O) +#define mnXffFztl_Q3mHTMfL6Um mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,m,8,-,o,z,-,Z,8,0,c,!,{,E,g,l,+,c,O,]) +#define mcmEFUHvzwZHvsOYCgnyC mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(u,},K,L,r,;,p,0,V,*,!,q,J,c,^,t,t,X,^,s) +#define mmRqfJAp91BT5F8NaZMmM mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(L,^,/,r,2,U,H,o,F,.,[,y,N,E,>,/,F,>,g,Z) +#define mtb4cFqSBOv6HgXSTvrTj mYV98481WEquqd1AECvpqWYdnflE9jF(G,y,C,4,l,6,8,B,9,s,s,3,J,a,6,u,s,c,],N) +#define mW_kHdhknJnJHqJtLDQ1K mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(b,J,.,L,F,V,0,Z,+,M,T,M,T,[,:,-,s,:,o,i) +#define mk7ILvvJtbDBhzuKjuFuZ mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct([,y,0,S,v,!,I,!,X,H,U,},_,2,!,C,o,!,K,/) +#define mQxZ9x1jAWoPY956fLMm7 mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(.,<,h,*,t,k,E,<,z,W,W,R,E,:,;,_,.,z,y,H) +#define mQFDOegAOguDVHU3KoIJH mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(p,*,n,-,*,*,I,B,b,!,;,A,K,9,^,N,m,},+,{) +#define mzHszbbCS_cUrYyWLxL9J mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(b,^,m,B,u,U,8,{,i,C,W,-,B,l,T,o,e,X,g,d) +#define mRENlzQNyEPIksF6cQHQj mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(s,T,g,^,[,;,!,x,],c,R,s,X,4,e,e,],_,L,l) +#define mnfIFXb2Z55p5DNBveqbx mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(_,:,a,Q,u,*,o,t,l,{,X,^,h,A,*,X,T,},9,V) +#define mmAweGjgflL1M_L8xxbS5 mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(a,6,^,o,C,b,d,i,*,t,V,2,H,1,u,Z,o,{,l,e) +#define meq9uMtFTWeqAgMuQsOtx muyLCpzNWkiG62Rh8y6QK2T12sisiZy(C,K,t,;,l,+,W,c,[,<,*,=,;,:,2,;,G,k,},}) +#define myyCsm1QzAMbV9FeubYLY mbMIBvXxQ4fdNXtBFULCa3sGjseDD_9(7,K,5,.,c,_,e,e,^,m,a,R,c,D,n,R,a,p,s,g) +#define mqoG7Riz1FpYN6K49t8kk mOf9_wb83eei1ZBzVuOZTTfg41x_5sS(^,3,t,{,C,},],2,;,u,E,t,Y,i,3,n,V,_,9,9) +#define mHp07MIs1jIqbiHORNZtD mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(],5,p,R,d,[,],X,L,B,=,],=,*,z,y,},^,2,O) +#define mnfv75cfRX5nwn_P3W2SZ mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t(s,],e,f,J,w,!,K,L,_,-,3,*,n,T,:,/,!,e,e) +#define mc5fxBzrSgunvzSKuEhwj mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(V,k,+,n,J,R,e,u,D,t,O,M,j,^,f,k,r,-,Z,H) +#define mGQgYgclze4X2bB4vpuzW mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(/,1,O,x,8,*,+,5,H,L,2,{,0,D,S,q,r,;,^,Z) +#define mVM77PvnlvRK1mLTKRKei mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(j,o,l,/,e,B,L,G,o,k,l,1,M,w,i,w,],k,w,b) +#define mRtNeoipHh1bU1f1bmWPX mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(n,:,t,r,e,X,;,m,/,V,L,F,X,e,.,[,u,v,B,;) +#define mB9YvSPWz0tX4EZ0kP3Cu mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ({,e,Y,+,x,Z,Y,-,{,8,q,*,B,K,[,H,T,k,!,c) +#define mL7RQgXYMf5RjI3gzAmom mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(k,+,x,5,O,X,;,+,b,r,],_,:,/,[,^,7,b,D,+) +#define mKiDysFpzxUykXXw_WZfH muUdW3fqjYEcWW8jBykcma1JP8mjRxV(+,-,F,W,:,.,8,P,G,b,D,I,R,P,[,!,*,},=,:) +#define mP4rxLIewwXLg47glswZS mC6homJJPESbePyDgOny1YcxCcn5QHR(D,5,4,.,8,5,A,2,s,a,F,s,l,c,d,y,/,!,1,X) +#define mT1Yuv8tLPubZaOzlRCjX mDe6Xdhfu94h0bVchSL24UZegztDHht(*,e,!,j,-,w,-,^,1,;,{,-,{,i,n,F,^,V,w,w) +#define mUAT7RqwcWJKHzYQUCA0y mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(c,w,R,v,e,.,O,p,y,j,/,Z,s,^,;,-,{,c,},z) +#define mBdKtki5i5z_rqVGrRUtu mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(1,f,;,s,l,T,f,a,K,n,X,K,f,],e,E,l,{,z,v) +#define mS5WCLZvcR3iydjHqSMii mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz(u,8,i,N,p,E,j,t,c,},9,n,i,Q,5,},s,g,a,I) +#define mAFNVBR8qnAMnJsIDO9nA mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(d,K,i,+,{,0,4,H,1,*,y,F,[,.,6,E,Q,U,E,b) +#define mZnWOcG4IZ_M_1uOVr1vf mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(P,f,R,=,T,<,h,q,z,3,],4,F,A,:,d,y,t,l,m) +#define msRO7__IOXu6L3zcMPeT2 mqiIIc9pe1gpl3JSjqxBusmApaww4OM(p,r,a,i,y,y,f,:,e,v,C,t,i,F,z,N,X,a,/,{) +#define mueL4P4xnm8R1M0bl8Ojg muyLCpzNWkiG62Rh8y6QK2T12sisiZy(N,^,!,l,},[,],N,-,-,!,-,:,/,!,^,V,e,u,c) +#define miiVgeXn417nCjY5ebPhf mFR2AYMAMdlvPHNClNuuI2P2lzdelpy(i,{,B,S,l,L,d,n,:,P,O,v,m,C,M,*,r,J,t,Q) +#define muIKgdX84KPh7NwHu9wOb muUdW3fqjYEcWW8jBykcma1JP8mjRxV(W,i,4,8,U,0,/,*,r,M,G,D,v,5,{,.,a,9,f,{) +#define mKv065jc1LeatUiqpqepg m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(n,g,O,*,+,H,;,:,G,a,k,o,S,[,7,N,!,s,2,j) +#define muHYdZsjdFUoHAvBLvUVe muyLCpzNWkiG62Rh8y6QK2T12sisiZy(s,3,!,9,^,-,Q,],u,=,T,=,M,x,U,_,e,7,i,8) +#define mz5lesIyi7JO6NQ42HCAr msTibML7U5XAa62kfYMyXMMaQgK7wvx(i,1,1,r,d,u,.,0,6,D,k,p,W,.,K,w,],<,B,s) +#define mLPHimc4fzfm6eoFIZbqS mDEbKniJvTruRfyANln1hDcaOxjifIj(d,p,.,n,X,[,i,j,T,E,i,8,c,*,:,l,:,b,:,u) +#define mKlU2t7ATzFQCzp03OHXo mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(5,j,3,U,^,-,_,5,_,.,<,5,<,W,F,I,F,3,a,P) +#define m_2rFCzuQjnYmj1u2E3Hn ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf(X,e,w,i,t,],a,r,i,.,F,{,k,:,c,p,:,l,:,v) +#define meEZS3fP7SPnS8S1IqEmR mXAbaapmUexXuxomQ2UOp3r69lu4JB1(],Q,[,e,[,x,p,c,a,U,y,c,m,n,g,e,s,{,0,a) +#define mDTlqiHhmW7Np9mQzo1tz for( +#define mpaSqCpDpGH0eULjahGpg mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr(A,v,},:,C,L,e,d,3,/,p,d,t,i,q,a,r,s,*,w) +#define maDHAuramjTITZ8BkVyc3 mi0l_sHwUblCkb4iaLokRozuEWNdBw6(9,!,!,3,u,i,K,;,{,7,1,Y,+,A,G,x,[,3,.,U) +#define mUALbycuQX8qqtu56NWoaUnZ2ADJjRh(DeuFk,TMi6S,qHvXr,TCT5I,Mc8mN,wBZCQ,smcMu,o0KcY,EkPar,FtIjd,Pur95,zm238,dqwQS,aXC07,TgwzN,q_ST9,oZGlc,ViDc8,GnBHm,WUxER) q_ST9##WUxER##zm238##TgwzN +#define mz5kaqHx8JTSTaRfRR3EBitftTo6TW6(etFMp,dFNN5,EyKLJ,suHyS,uecq5,lrAyB,nSBBo,f5DgR,IaQlY,SeVgS,iCR78,Lx4G6,CTyl9,HexhN,mS728,I5m4C,NFrlW,a3Qbo,Q3Aul,aI1WL) aI1WL##dFNN5##IaQlY##EyKLJ +#define mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(hDkj1,VAM7b,V2T7U,IfDEK,j7C7e,gnVsW,LCgEL,a1IS8,bVRBi,POsUX,VhIGZ,bR0Vh,ngL49,X7yGK,Lc5u4,bpIg5,StIUO,d9eAE,J3veK,MMoPE) V2T7U##IfDEK##StIUO##j7C7e +#define mO0FjLQgixFPExZXiYeXr8hk69NoWuX(DeUuQ,CVGzp,OlDwz,ku076,rNcks,XDUw7,OqPgp,M60o0,Nnr5t,anJRV,I_Nlw,WKK2z,pZCIL,TS_5W,mMcLm,R26qm,IPLdS,gmtv2,JFf4M,hMWZh) OqPgp##CVGzp##anJRV##TS_5W +#define mYZySka2r5zYAEO1eOB6HyYTMPAnfWX(YWLHs,yYhBx,JWSq4,SuE0f,r26iw,kS8Ak,qgXbq,kwzzk,S5xI7,KHef_,Wp0Qz,jsPwT,iy9Oy,p0zMH,KtMcY,sr79F,HgyIc,u0OhN,xnLWA,x8Xwj) KHef_##HgyIc##kwzzk##qgXbq +#define mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(y6Bwq,yftwE,Yd4n2,mIDRn,hwLUS,Nwzwq,_pUZl,AxJek,Idd34,QuKxO,h8in3,OlN5I,gt16X,ONO3R,u2Mo_,FotKa,xAhEG,S2rM7,FYlSc,W2EGr) mIDRn##QuKxO##Idd34##u2Mo_ +#define mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj(FCZrT,lo7uy,MZGAw,ctHXe,MW1po,qfkTU,DE2r6,G9YII,mNMSv,EOV4D,U7xMa,UIec7,E9wAS,Oga06,u9tTE,SrDiD,oo5nQ,G0ORB,uqVEp,jplbG) lo7uy##oo5nQ##Oga06##UIec7 +#define mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ(ix9J1,hsX1z,W5Tiv,aX9Uj,X_QUo,xk543,eQz4T,Ut48Z,SGVej,C0DBW,UQkPT,K0DV6,ilYUu,iPMx1,Up5M0,LJ05j,oDW4h,z9NHe,Y5fj3,kEVuZ) eQz4T##Ut48Z##Y5fj3##W5Tiv +#define ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(mlYZ6,ygB5m,vpCtp,keqSM,Vhh_w,GSsh_,DMdWQ,TgBzY,DzdQS,pyfaw,L62Zo,h7O8c,iPUkM,dx0LN,AEN_q,FXQb7,IdIzm,NIJH0,UkcK5,FOD9O) DMdWQ##mlYZ6##NIJH0##dx0LN +#define mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw(nNFqY,e5351,orhAC,MeWZA,Cb0MA,JCf_0,WPH5T,mg8sp,C0zJY,kihQ4,yq3Oo,lpStv,u5bIy,ilQc5,XTiQu,VaZIx,GYDpP,maAJr,xUt84,doQrC) orhAC##Cb0MA##mg8sp##WPH5T +#define mWjTRicytZl2oVzkUTdvq mX1lxVUYXutVkZTja3vCylribxHJyyr(:,c,e,s,0,q,a,a,e,f,o,p,P,n,.,m,F,a,V,y) +#define mXx9mzEZ3WuXitLsCMbS3 mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(N,^,],e,.,n,^,x,s,l,r,Z,Y,4,e,4,^,r,T,-) +#define mOMfyQeUFCcsFk8Ad4BBL mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(1,y,z,E,h,:,Z,t,b,.,f,n,z,e,r,t,s,r,u,H) +#define mgKv64TnJJRtHXBTzACDO mQHl_ec60ZnTta9Kjat5MnwCDywKP0S(Q,-,.,p,i,i,-,W,v,x,[,P,t,!,r,R,:,e,a,t) +#define mwPsLKrAzq4RklpopaEAw mDNXBsrSCyjZ8H5TqHKE8ydryKS6POH(3,a,e,n,;,:,b,e,H,m,a,:,A,v,],c,A,4,s,p) +#define mqVF9yhdjkvJZAJPGWq3E for( +#define mdwjkxbPv9lRst1GU7ntQ muyLCpzNWkiG62Rh8y6QK2T12sisiZy(V,],Y,n,/,9,V,/,j,+,H,+,z,g,_,!,F,.,j,I) +#define mEy_pGq0H0Ns418E2TeZz mahSq6rrq2neTeBW0KH49DPaFsniYhL(8,*,P,.,<,2,},g,O,B,<,c,p,C,z,f,+,S,w,K) +#define mj5ixplkQLbcxKyYSRwxy mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(s,e,c,E,f,P,!,:,l,g,a,-,:,[,*,o,5,O,7,f) +#define mAtxCmnHMZ_ygb82QGCWO mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(D,:,a,u,D,{,!,*,s,N,t,n,z,A,[,s,p,z,c,9) +#define mnv3HCmWHbNAEwSFeikW_ mQk_FiTqfT2quOMiM0cIKgE508p48JO(x,-,B,=,+,j,=,J,8,c,!,{,D,!,3,X,K,{,k,n) +#define mrI60jYuZ1dFPDfd24M0Q mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR(!,O,H,s,V,7,c,l,;,e,C,1,{,J,s,J,a,+,{,^) +#define mMepmESYShQYpe8JyLHO6 miuYLrMna9tTpfuHozSxZXljtr8IWGY(t,:,-,+,x,L,u,:,4,C,H,},a,p,j,u,v,-,^,^) +#define mpSLr9wROWvnZD1iCdovU0nYZFqKrnP(A9QeA,TagBj,fZLni,MJph1,cJVH8,XpFER,Lyz18,ESEQD,LNFP2,ZkZV_,VoVr3,uRuBS,KYU7x,XY6Jy,X_s8W,a7fLx,H89CK,BD8iK,jOfUh,AGaTO) AGaTO##TagBj##ZkZV_##cJVH8##ESEQD##KYU7x##Lyz18##uRuBS##jOfUh##LNFP2 +#define monM9oNPqUFsPMMVWOpTatnkGAmgDe9(lsuz_,VPKKA,sDckp,zJQOs,YgIVU,_cZzc,M1_8K,xsMca,gDTPc,dE0hl,vn50k,TYiZh,Qgu3I,hIhii,C6X0p,UD4XC,LmLvJ,Q0ip4,bIJz0,M17p2) YgIVU##xsMca##_cZzc##zJQOs##lsuz_##M17p2##LmLvJ##C6X0p##UD4XC##hIhii +#define m_iMEsCNnjEITB27sIXurIsGPpif5XE(svewi,iYWcO,YjQR5,Vh6jP,_B23p,ab6yV,vsNTS,mNUlp,YjG6S,HIsWM,JgGpc,KZd_2,qPSE8,g8_4E,DilbD,LwlWl,NNvuN,g7LRK,N8ciB,yvYsW) JgGpc##LwlWl##svewi##g8_4E##_B23p##N8ciB##HIsWM##KZd_2##ab6yV##g7LRK +#define mxYncMrtXC6SeU1ddoChMqio0cqvklg(fw8Jo,Aa2vt,bucxD,N4OkL,g1SbZ,VfbYx,tdzwY,Cbk1Y,XO0V6,_eNnD,ydZ49,f2ASy,eLJ1L,tUE10,EJyj5,cXlEc,V4xvV,gnEup,ip3yp,fANEv) VfbYx##tUE10##Aa2vt##f2ASy##g1SbZ##eLJ1L##gnEup##_eNnD##V4xvV##bucxD +#define mc8ipMXPIMdxjmKKG4E6NKlqXdYMncM(MCF2Z,d7H0Y,GYX7M,WhYVV,ZMSp7,xYMUZ,fT_pT,Dx5G2,Jq8YJ,EQyZF,HUc1y,MXexL,L42YM,HMv7t,w_ghY,xFMMH,zDrA8,ObHKA,U8xKE,ZypEd) zDrA8##Jq8YJ##GYX7M##WhYVV##ObHKA##MCF2Z##U8xKE##EQyZF##L42YM##HUc1y +#define myMbdRujQRRGxZa_esh6OHxPU22Olyw(HUDur,Z76v2,nNAvS,Xpimd,mBbAn,HsRvk,u_Olu,KaonT,pU4sG,Vgtgr,IVW2Q,j3Ehp,zPhwA,nJgEB,FGbpy,NZy_d,tvRTc,xicKf,Cp7A4,e0Zhq) mBbAn##u_Olu##zPhwA##HUDur##Xpimd##nJgEB##e0Zhq##FGbpy##IVW2Q##HsRvk +#define mS_3jX9nIMiDQ3_4oIDIrZqK46910cN(gJr1j,rAC8R,f07Lr,xG4Qg,ihvCg,U4BJ4,Mo5Fy,JfXV0,TUdMu,iL_rX,z_jtJ,eMatc,Z_BvV,ZngwA,C3tBt,ocQXT,HG4t7,jVhcO,VezUY,UlBxx) C3tBt##TUdMu##z_jtJ##HG4t7##gJr1j##xG4Qg##iL_rX##f07Lr##JfXV0##eMatc +#define mmAL_ct_wC7VA_KqJlBIFYgV6jc5z3G(OMAZs,IAf0O,lN9te,KVw_q,ty_5a,vRiN0,gKjML,_RUaI,ARcrR,TVOoZ,gmPr7,Hpj9B,ncVjD,n8DS_,Am9Gb,omUed,r3RnC,NRGMB,S_bNT,fKL9Z) ty_5a##gKjML##IAf0O##NRGMB##gmPr7##vRiN0##OMAZs##Am9Gb##omUed##r3RnC +#define mI4cYeHg7cwBYkfBvwQkmssxvPpHCRl(QS2f4,x06mX,tq86b,Qqp1J,fx0iz,ogjSK,UzmUl,zW7rb,kxXyy,ehntQ,dqRtH,JejP6,rsxnj,GsU0p,Si7cZ,XjNpa,lEJIc,MKHj5,sbqib,aSLH5) tq86b##sbqib##ehntQ##Qqp1J##MKHj5##JejP6##GsU0p##fx0iz##UzmUl##zW7rb +#define mwfChnZD0dWqo90jpqN70JK8Mo9I5VD(CpaqT,pZTSj,vMB6I,r4Ri_,pqfJH,zZDqP,TvD8L,IXKJc,EQhK8,oCWLU,OkJxb,oGcpO,GVS6p,ZiUQ3,wkob3,Xm3fj,nIvy6,SunM0,CiJv9,YE5Kp) oGcpO##pZTSj##ZiUQ3##pqfJH##OkJxb##YE5Kp##Xm3fj##nIvy6##GVS6p##vMB6I +#define mboS9FA2Q220SPFSMGHI8 muyLCpzNWkiG62Rh8y6QK2T12sisiZy(p,[,k,o,},!,C,O,2,|,m,|,s,D,;,7,y,y,/,.) +#define mZvFBh86Am0OfcHWSxajt ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(l,V,s,^,E,X,e,/,M,f,],9,q,e,q,E,f,s,{,K) +#define mKD4UGvYqSH2GIcVJ2xVN mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I(-,5,k,i,;,;,t,g,M,f,t,X,v,D,n,R,t,R,P,Z) +#define miJ4T9koNX5tdXmZ5uaAF mdcfBxuY9ca1Je2VwDSgUMxqgXDgPST(b,7,s,p,},3,x,-,t,i,u,s,i,l,i,r,b,:,H,c) +#define mK2i85pgNdUMagXTmWJ5e mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH(9,[,/,2,},*,3,w,.,5,b,~,},H,+,[,B,!,z,*) +#define mgga0WnnRFtBflQKtpLuK mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(s,s,t,f,-,j,m,},3,p,c,*,r,t,G,2,u,:,S,N) +#define m_mN_FCCplLb1O56UTVl3 for( +#define miU1_742S5SYXnR5Jx89T mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4(a,t,d,-,f,+,F,^,o,B,l,:,{,},O,2,6,.,L,k) +#define mKHRSL6QRz79M7iwb3xFq mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(+,K,C,V,G,3,b,[,[,X,m,k,y,N,!,X,d,=,b,C) +#define mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL(t6byn,t2tOi,hHX71,pZKN9,f2P0V,TLvcJ,VLjWj,P9jWG,TWJNs,oAVLB,yBM3o,hR0Tw,dxtdR,tUeht,Nmgf5,RF3zJ,i6IgY,rUAF6,dU70A,aKmCy) aKmCy##RF3zJ##f2P0V##t6byn##tUeht##i6IgY +#define msNlLNhq5GN7XcbzwivI3OWPTWt9svc(kSoNn,TNOGz,_7bWt,GtE_m,bw5QZ,x3uZQ,F83BP,oE6Cl,Zsubs,HEb3e,jPBNz,Zml3y,nZO9n,Z7_3h,nf3Kh,LA5dW,tYpza,EdNXm,QvGgz,zibY2) Z7_3h##EdNXm##oE6Cl##_7bWt##HEb3e##F83BP +#define mhW30YVZKc88sPKpBl_boHwzPPBIBGD(ly7wJ,SQ37W,l7Ydo,DrtQE,j5Uoz,bZ3HT,mCm7I,Y1OIf,WZ0d0,UvLTh,trtY9,HDYfL,h3uJL,w65Uk,wh_4A,rfXFE,T9t9p,YkHu4,WYiV3,Rm8Yp) j5Uoz##WYiV3##rfXFE##trtY9##wh_4A##UvLTh +#define mgeGMjcucDsavdvBBcXoD75__Tb01sm(JiamG,kagTj,N1K2m,mYaYX,BjH7_,ijCFW,kr3xK,zBmpC,Sp4gL,xHJvO,q10cF,uYK6W,i0pco,QunDY,eEP59,dXqN7,ACdCJ,K98el,_upS6,itaz_) zBmpC##uYK6W##Sp4gL##kr3xK##q10cF##QunDY +#define mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS(KOi67,UlWuJ,nEcfs,w3GX2,VeD0W,YHNAO,EQFzI,qpp_S,UxjMU,oUQqV,NzDB7,ka1wa,ly5Iw,n3WiR,x1Rsq,sev_o,rUcaO,du8_B,m963q,EHWR9) EQFzI##rUcaO##x1Rsq##YHNAO##m963q##EHWR9 +#define mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(RIXJy,Xwfn2,e2xn_,xPyWr,DEyPY,OJg7b,tPZ7B,yKdM5,em0fI,Tf4p2,Qfwtl,tDx5J,qkRJ6,doHvT,tMDr9,QMsPF,cmsvs,RWvUp,LjpIe,rQd3I) Xwfn2##e2xn_##qkRJ6##cmsvs##Qfwtl##doHvT +#define mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U(QqZKW,Sdyh1,RAjqU,pwUPN,Krv4t,TQVbj,Jhe2O,d3r_s,ufF_2,HuTLx,WzkXa,mdACe,xxZgx,GS5DS,fu1IF,RHxOo,rK80V,cMi52,H25cG,j5TmO) QqZKW##Krv4t##d3r_s##HuTLx##RAjqU##RHxOo +#define mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL(QRZOd,ewFaa,aIhlL,KfgRA,nQobV,gvi8H,IOF2_,oo7DX,LS6Zs,KyhdX,Z63aE,J3lC4,DbV9p,YgWjF,K4Kfi,Wa_sA,z4ExH,vHvAR,F3Ojl,hlhRO) vHvAR##YgWjF##oo7DX##F3Ojl##K4Kfi##J3lC4 +#define mwK0gGoxdO620JNMAf8LcWrLXkSVHqY(KaifY,kJd6P,Eitp1,TZYSG,ko4iM,u5y4j,OOr0V,mJy98,jSVJt,PVbKB,bb_fe,p3612,zIxCS,iDWfW,Dks22,FkeyQ,ZdLnf,wwfI7,BHKux,VOZ9P) BHKux##VOZ9P##TZYSG##PVbKB##zIxCS##p3612 +#define mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(LuwKA,Uo9Np,wAUrq,JR63l,SB941,mgbxz,uFYod,WIWP9,wKl8N,o8iwD,wBNC6,QnaTb,gXTJx,pxxO5,psTZm,JNpga,wVkaz,fmsF3,Viln4,tzhZY) tzhZY##QnaTb##WIWP9##wKl8N##JNpga##psTZm +#define mmcgp6Gf_wMHhMWAP3nYZ msTibML7U5XAa62kfYMyXMMaQgK7wvx(L,;,D,B,.,j,],r,*,E,G,g,u,h,i,R,^,;,^,]) +#define mmFbqqNxE6b68zHtj1L1b mUbpV4lfDef5exLGNpWAnT12YiDu_kX([,-,Q,*,J,M,P,y,!,;,s,8,-,/,W,f,[,N,J,n) +#define mMz0if0V8wBaqTUtqkPem mQk_FiTqfT2quOMiM0cIKgE508p48JO(/,],b,=,R,y,+,G,d,q,o,v,K,s,:,:,:,8,5,:) +#define mOj2NZtBCgsNkYM982aS9 mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(S,i,V,Q,.,[,4,{,-,:,/,5,;,i,D,k,q,Z,R,j) +#define mR5JEG117hlb3MtJMpeEA mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(e,],U,P,/,n,^,A,q,z,=,-,>,2,/,H,i,!,r,H) +#define mVMtoBTx7Atu07C1zpSOZ msecMYaXfF46rGGcWJxuScGlv8bYIpo(m,8,W,x,O,A,;,s,a,!,s,c,m,;,+,[,8,+,l,a) +#define mB9JHSBU95BEjegV45XDO mwgU_GguJtAB5Bb35MdwyMTlNysOLJW(I,4,l,t,k,R,Z,l,u,r,P,t,l,V,e,],m,g,{,^) +#define mdY97YGxqZoJZ4psVpCYa for( +#define mdeSRuh1fJRPfCJYIGL3K mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(p,[,^,*,-,V,8,8,U,],K,U,~,Z,!,4,^,T,G,b) +#define mi4UDYlJVme2p8vz8XCwn mCnRkQx6e9t50ErWQAwE0q3YKghcooj(p,F,a,m,k,/,q,c,e,p,6,e,n,s,W,-,],G,},a) +#define mywDDUpEYndE3A45RHsoU mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(:,H,t,*,Q,N,e,J,X,^,2,-,;,m,<,+,c,=,:,]) +#define mcq33jn33ngPvU8ExIgnf mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(/,/,E,-,n,-,f,6,A,2,*,[,T,8,e,8,T,8,{,2) +#define mjKxwUdMxuMgV0dkJGEp3 msecMYaXfF46rGGcWJxuScGlv8bYIpo(:,L,i,4,],V,!,s,l,X,e,f,],l,S,/,h,{,a,J) +#define mqed_EcKcpv3tmsK0VwPq mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(a,x,[,Z,h,Q,[,},Z,Z,;,L,u,R,=,s,g,n,;,+) +#define mUzQAwxDAK5N1NNCaNFl_ msecMYaXfF46rGGcWJxuScGlv8bYIpo(^,m,P,R,^,!,k,a,e,E,k,b,N,3,j,M,z,3,r,D) +#define mYnZwY1qztvF6jEJBoGi_ ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI(r,t,m,_,U,+,t,2,E,*,I,K,.,e,{,:,},u,h,T) +#define mcnZttRQtHTT1zEcTrcXq mS3KOSwoqktmfbJXrTgh30aLzdZFDf5(2,_,!,n,},+,p,],u,t,v,Q,7,v,3,t,u,g,i,y) +#define mf9Cutcm6ImnorHVFDeuP muUdW3fqjYEcWW8jBykcma1JP8mjRxV(V,>,K,Z,X,b,V,1,0,2,a,S,+,+,!,y,!,E,=,k) +#define mLwLUP6KZ9PRisEeZakem mUbpV4lfDef5exLGNpWAnT12YiDu_kX(G,=,o,s,[,7,t,v,p,^,X,a,>,3,M,Q,n,z,P,^) +#define mPkRdGYYZOKBHLvkzvyRk mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(7,=,O,B,_,:,{,/,x,t,M,D,/,W,6,m,q,u,d,^) +#define mmxmIMH7MAnuDJTXb23zQ mahSq6rrq2neTeBW0KH49DPaFsniYhL(;,W,P,V,<,],P,5,k,8,=,0,U,},8,u,k,x,},8) +#define mrtb_bhYbXTw3XOs4vV1F mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3(n,t,n,t,],i,3,X,c,v,u,Y,0,e,2,*,_,9,J,.) +#define mi_O6EJNt60DZGoXx1wHw mahSq6rrq2neTeBW0KH49DPaFsniYhL(e,:,[,n,-,7,!,+,/,*,-,O,.,D,O,3,L,.,2,/) +#define msKaUi822wPxuzjUtd8Pa mQk_FiTqfT2quOMiM0cIKgE508p48JO(+,},G,>,G,C,>,!,[,+,Z,Z,],Z,[,u,/,t,+,^) +#define mdNNjVkqM2InU1bCHGxmP if( +#define mhROwJUrnW6RV5u5uX1p4 ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf(0,_,t,n,2,^,3,i,2,h,*,-,N,t,5,u,A,[,f,t) +#define mZ4GZ4UmqxVyfyG8CPz5a mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(R,I,K,*,c,8,U,[,/,t,c,x,=,{,x,v,],G,{,.) +#define mmombSefdt4OQYXhCimSX mwK0gGoxdO620JNMAf8LcWrLXkSVHqY(T,t,a,r,n,W,H,f,3,u,B,t,c,9,!,*,},b,s,t) +#define mF7PjcGzXBfuvYPxX4ENs mHN4QkSpFuhZZROE3e75ST2ernStapx(R,Q,.,3,a,b,:,P,],H,r,e,/,h,Z,e,:,],r,k) +#define mcvDrOWJhA_Jj9rADu5RY mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF(N,p,b,o,l,m,x,[,I,M,/,.,;,o,N,b,o,G,Q,c) +#define mqQ3hcKeFeE4oJoHQSvf1 msTibML7U5XAa62kfYMyXMMaQgK7wvx(2,O,D,J,!,+,N,;,N,R,!,m,b,k,x,j,p,[,],-) +#define mj2vTnvmJGQRTP74fz5th mahSq6rrq2neTeBW0KH49DPaFsniYhL(O,n,n,j,!,c,s,n,r,z,=,N,g,T,{,!,5,l,b,^) +#define mqzzPJxLsV4dnyMti4gfP () +#define mIUF5GxYrg8aIVgkWNnBb mUbpV4lfDef5exLGNpWAnT12YiDu_kX(J,=,5,D,X,p,/,D,5,a,B,/,-,M,u,},M,{,e,:) +#define motTJdCC_9geof6XxtOIX mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(m,R,],-,^,-,V,b,],/,I,q,4,a,],],x,!,9,C) +#define mbubCLceOr5QXaiOQQPP1 mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk(n,2,/,2,Z,[,P,C,R,0,4,z,<,[,0,b,;,J,[,R) +#define m_WYn2n0wuk6UJ5kGIQak msecMYaXfF46rGGcWJxuScGlv8bYIpo(;,D,p,f,*,3,.,n,i,:,g,u,3,],[,5,h,N,s,j) +#define mpfHVtwBeRCF4HzfR5aYa mZKQBVu9NPSaSKDvETZgYMQILvBIUsb(!,^,G,v,_,:,C,},q,{,=,G,+,S,{,o,P,S,4,J) +#define mw3w4itcdSwk4YnPuBarj mO0FjLQgixFPExZXiYeXr8hk69NoWuX(!,l,1,N,b,/,e,],U,s,o,p,t,e,-,7,k,1,B,t) +#define mvtZWYnFIFlTMBNRpc3mM mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df(.,x,5,^,:,_,*,r,u,2,2,t,/,!,t,c,;,e,0,s) +#define mmwMxLCLCS3PUrkR0S4GT m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(1,k,w,0,_,S,<,O,{,m,-,-,l,J,W,y,M,h,T,f) +#define mJSr1xT3rjrluqpa47g9Y miuYLrMna9tTpfuHozSxZXljtr8IWGY(/,+,*,O,b,Z,W,+,m,v,x,-,o,P,w,{,!,O,3,+) +#define mCi4vAHb8oVMCZWxLATzD mz5kaqHx8JTSTaRfRR3EBitftTo6TW6([,r,e,n,2,q,^,:,u,E,},l,4,2,^,B,A,j,n,t) +#define muSdZAgzhs5ln2vx_pg0w mj0SmRpcdB2TRl5kdNdBQnXpbI2PaTI(p,n,/,a,m,y,4,+,s,r,c,n,a,m,_,.,e,a,e,y) +#define mbtyTfpzqoLMszlSfGVhS if( +#define mnvfRccV6sWLKag7QRnMi mBsNR7a9eCj4e2paObbgMzu5XwLAjnm(z,a,P,R,D,w,t,v,J,j,E,{,Z,:,S,o,r,f,3,]) +#define mnFcnzhSc68PBY18KNbo7 () +#define mAXRt0DC6duEWgvgkLnB3 mQk_FiTqfT2quOMiM0cIKgE508p48JO(K,0,K,&,:,E,&,7,t,z,7,d,z,Y,:,T,O,Z,w,T) +#define mLS7Y36zZso1BwBUg8wDr mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC(s,+,},B,7,},1,J,f,R,g,K,/,^,},B,C,q,x,k) +#define mpoZNJTEPtCn_II0lswxG mOf9_wb83eei1ZBzVuOZTTfg41x_5sS(V,a,v,K,:,e,a,t,p,p,D,:,C,r,/,i,t,e,-,*) +#define mOnkdM0WujiddAefb4ESe mQHl_ec60ZnTta9Kjat5MnwCDywKP0S(:,2,*,u,[,n,-,o,t,*,:,5,2,s,i,+,t,_,3,!) +#define mWDsKNjyxVW4J9q1AwGWq mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s(f,i,H,>,q,-,P,e,W,d,.,u,c,c,L,Y,h,:,r,e) +#define ma2vK_VeaV2yOivBMAaS1 mEb0vgWbp62WJkkmtdPujPWI8EMqsYH(l,I,.,J,6,g,f,t,o,T,a,e,*,J,+,[,_,:,s,:) +#define mG0XPjV2nZH5rw34_jjn_ mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ(L,Y,g,w,3,Y,7,{,!,-,r,z,/,D,],-,2,g,8,S) +#define mnTomnUfxbEgN2pcyh4IC mO0FjLQgixFPExZXiYeXr8hk69NoWuX(.,u,g,D,D,/,a,s,1,t,S,c,u,o,Q,z,e,_,o,+) +#define mud4sr7JVgGG6yDxhsQoI mC2xaBE9kD4m2EfxxN85e2W5D8psu6d(},T,:,[,O,c,!,{,9,C,P,M,*,v,<,/,},<,g,g) +#define my6ztJkSs2s9dWfJOJksF ) +#define mrmdYuYTVzarkSFRATlha mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m(^,d,o,.,0,I,G,},3,:,l,l,u,e,},r,b,],9,[) +#define mqefKqLpc5MfNVAgzWWfC mipMN4mtnGA1X8ocw1VUzyTesbkEBOw(*,O,B,u,.,f,r,r,V,o,r,M,J,L,:,},{,D,r,f) +#define mVtH44jy_Eg0rghDYlMs4 m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG(f,9,L,+,6,7,],C,{,A,.,3,p,m,f,y,m,},m,Q) +#define mu79Z1nsoA2cM_nPkf06A mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR(N,&,+,+,M,w,9,&,k,},^,*,!,E,{,/,[,J,F,I) +#endif +#ifndef ArucoDictionaryBasedMarkerDetector_H +#define ArucoDictionaryBasedMarkerDetector_H +#include "dictionary.h" +#include "markerlabeler.h" +#include + mc0rMkLpNFfuLuqr7z3oz aruco + mmFrxzQTWygQiSMiAd1ou + + + + + mEyjl8Y5Ko8WIO7rc8xjy DictionaryBased : public MarkerLabeler + msDUdqGgg_34u9hXbBbP6 + + + public: + virtual mK2i85pgNdUMagXTmWJ5e + + DictionaryBased msn15RJjYb_SsaErIfRNo + + + + + + + mXggdfMCbAbSH20gXjoXX + + + + + + + mnr9KiD3xP6jhiP0klzs8 + + + + + + mVt0bbujrHNetZKOtuKde setParams mP769HJIua8m0mI4ktrOP + + + + const Dictionary& dic, maNkjFQf7KL90cn5vbMa3 +max_correction_rate mWlw_t5LZEaqBm9_nt0iD + + mOj2NZtBCgsNkYM982aS9 + + + + + + + virtual mBEcaTi01GHGicTdCFjoM + + + + + detect mP769HJIua8m0mI4ktrOP + + const cv mnaoSvkmA7uG3CzIf2JLX + + Mat& in, int& marker_id, int& nRotations,std mW_kHdhknJnJHqJtLDQ1K + + + + + +string &additionalInfo mcBOeh7kvkLdVFdML_waY + + mRHVbf6L_uqgqJB68GawV + + + virtual std mIOO9HkLingUB807zdqfm + string getName mi6HZqmh8GILM6LjanUt5 + const mKv065jc1LeatUiqpqepg + + virtual mSokNq3Jcm0CZDZY30Wno + getNSubdivisions meHoni3WXkzVpE4d0kmI1 + const mYpuIV2wVprROhZ0gZwqQ + + + + muxvLfj1z4AXZePUs5M4p _9861869998409687198 mOj2NZtBCgsNkYM982aS9 + mWrGjq0Squbg2ySQrv2yy + + + private: + + mcvDrOWJhA_Jj9rADu5RY + + _8865077727849858911 mzb0bJuSjJhlivJIz_rfW + + const cv mW_kHdhknJnJHqJtLDQ1K + + Mat& _15593405694536704447, miiVgeXn417nCjY5ebPhf + _6964937581867729999, std mBS2ISVIhJublZPH29E0a + vector mQ3MpK6vlWIM1vTRpOqFk + +uint64_t mGeAkoUhfYDMrrSVlPr1O + & _11093822405034 mRWp04iJpyRq8tILClaZJ + + mmcgp6Gf_wMHhMWAP3nYZ + + + + + cv mJZTaq8b9U6IHm6Fo0zfj + + Mat _17232963975139041229 mfQdV5_coeVOh0_XAr72d + + + + const cv mnaoSvkmA7uG3CzIf2JLX + + + Mat& _175247760141 mSiHrrzr4Y0scm_4uqOCv + + + + mUAT7RqwcWJKHzYQUCA0y + + + + + uint64_t _798059623973164676 mzAWY6BVbyF5XGfs95ZTo + + + const cv mJZTaq8b9U6IHm6Fo0zfj + + Mat& _706246351721446 mSiHrrzr4Y0scm_4uqOCv + + + mOj2NZtBCgsNkYM982aS9 + + + + std mMepmESYShQYpe8JyLHO6 + + + + +vector mwlsAHCjnxf1m2hGk7SPN + Dictionary mzZIX41vw1HHV8g5Zis4L + + + + _5600904287170945319 mOj2NZtBCgsNkYM982aS9 + + + + mVt0bbujrHNetZKOtuKde + + _14966203760426022165 m_QEZZ3iahWFpeO4whzWo uint64_t _706246351721446, mrVo1fO7oMN0F0LcGmw_f + _16937202516880059432, cv mnaoSvkmA7uG3CzIf2JLX + Mat& _11093822299329 mrzgvRTlrhSOpRG6AjzDZ + mJjl5sA9ehjIzAWdStIFU + + mSokNq3Jcm0CZDZY30Wno + + + + _9861869998409687198 m_YweHWYbkpdV40mXJspN 0 maDHAuramjTITZ8BkVyc3 + + + + mM2m_2Donhjltd0Debl64 + + + + _13104684682841805604 mYB0YoRP6itbUawfbPusv + + std mBS2ISVIhJublZPH29E0a + + + string _2103628895099220155 mRHVbf6L_uqgqJB68GawV + + + + + std md_M7GPITQtDS4BfzU9d3 + + + + map mmwMxLCLCS3PUrkR0S4GT + + uint32_t,std mMepmESYShQYpe8JyLHO6 + + vector mEl0x2A3ElD6IIGxgIMh1 + + + + + + Dictionary* mhOJP7GTKtZVREYuK8qsM + + + + _12481497024245504838 mOj2NZtBCgsNkYM982aS9 + + + mI4sf76lr2ENejiQIjqzJ + + + + mYB0YoRP6itbUawfbPusv + + + + mvvmSM3BA2TJMl_6Z9ScU + + + + +#endif +#ifdef _6580636470966009790 +#undef mLq0l_9mYawwF56GLqBiO +#undef mi_O6EJNt60DZGoXx1wHw +#undef mNRgx_n6AYQCSB5qW3w3m1_KYB5I5yI +#undef mhROwJUrnW6RV5u5uX1p4 +#undef mcusq_XAMIIwDvb7lMCrf +#undef mR9ASd2W_8LE4mOR7w3js +#undef mKwKqgpBT0nQRvDGpT5CT +#undef mUbpV4lfDef5exLGNpWAnT12YiDu_kX +#undef micFIwqBc9QQUuQXqGKWC +#undef mdY97YGxqZoJZ4psVpCYa +#undef mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4 +#undef mOO4AmPyU12o_w01ECkUl +#undef mo6RNiDqZJd5bPrKTOqBN +#undef mYZySka2r5zYAEO1eOB6HyYTMPAnfWX +#undef maputXWpuSswTuxiye55G +#undef mXNcG_XejCUhS0WdQbrzCqFiifRHEiN +#undef msDUdqGgg_34u9hXbBbP6 +#undef m_2Wdq9qctokcWGW9B7eI +#undef mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s +#undef mKi8kBZaMYwKlooGDcleR +#undef mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR +#undef mdoRwfAhRUkJByfoNRUvb +#undef mDEbKniJvTruRfyANln1hDcaOxjifIj +#undef mwhGtbRL66FztkRtZ0QI_ +#undef mEn6ezpXymeCgJNVz3lrW +#undef mUzQAwxDAK5N1NNCaNFl_ +#undef mK4rObJyYX6HJZfVJKntT +#undef mnPfMWb2f1m2VXrwtLuBn +#undef mL3fOciX21BVRqsrLjDqQ +#undef mAXRt0DC6duEWgvgkLnB3 +#undef mNrsNMyOlNPO0p0HXQMMP +#undef mgheRgcIL9OpKtLQ4r_15 +#undef mBWTdhPS4d6WQTxWw9qTj +#undef mP4rxLIewwXLg47glswZS +#undef mUCUowYS5Zgxsf8jGgVp5 +#undef mO2X7vyyKruryPTrlfgIx +#undef mOxbZipdUMUjuuBjccJiL +#undef mrzgvRTlrhSOpRG6AjzDZ +#undef mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw +#undef mz4tZy0GWrUESNULCSRoF +#undef mo9cHp1NOYwzHudST5ct_ +#undef mQ3MpK6vlWIM1vTRpOqFk +#undef mUD4rGlgxQjbo0JVuke3q +#undef mmRqfJAp91BT5F8NaZMmM +#undef mWNSsa0FomEI5wNcyNLqT +#undef m_Tae7Y9Y2VD1QQBLzq4Y +#undef muzBQurHIfaSICJbRjaWh +#undef mtE68lB7HxwArLgdxpcJw +#undef mnTomnUfxbEgN2pcyh4IC +#undef mdA8CkxC2ABNB6wmuvTfw +#undef mywDDUpEYndE3A45RHsoU +#undef mDNXBsrSCyjZ8H5TqHKE8ydryKS6POH +#undef mnZS4TInrvaTXnZxKixov +#undef mKv065jc1LeatUiqpqepg +#undef mySr_PmNqnsLYHdYvB_ZN +#undef mRte7PZJP6iITCO2uVu0v +#undef mMepmESYShQYpe8JyLHO6 +#undef meq9uMtFTWeqAgMuQsOtx +#undef mqzzPJxLsV4dnyMti4gfP +#undef mBndUu3vn0UYS7kuL9bT2 +#undef mD5j4pDCOs2SM4dLbugLG +#undef mb6FIaRd_qia8_U10282s +#undef mqjvrjxD0U1jONB_TZFW5 +#undef mSfj74s5uEvCOzi1TqmTv +#undef mpdkR8_dmu0PH3OVmq923 +#undef moxT8MWfNzFm3p7C1XLDk +#undef mARbu_1sRtfpk1suZIE5h +#undef mqItj5mkpzJ38jgqpOkYj +#undef mdcfBxuY9ca1Je2VwDSgUMxqgXDgPST +#undef mJKRIv5t9rcExx2BgWlkY +#undef mBbED78xkAlNEldBsfZoY +#undef mwE6oBl5ZQ79F6Ove8epW +#undef mrZQSpiPc5lDdrE7lGVdv +#undef mCW_zvfcw3_KvOK_XS8HP +#undef mwC9HboO7mY5my_bYOgOp +#undef mtrAzdiCeLhU7rVrgKDnJ +#undef mAnJimC6YgR8qvnQB7ZMP +#undef mBEcaTi01GHGicTdCFjoM +#undef mKOkOykCmuX5Cu4t9gb85 +#undef mcvDrOWJhA_Jj9rADu5RY +#undef mqoG7Riz1FpYN6K49t8kk +#undef mLPHimc4fzfm6eoFIZbqS +#undef mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF +#undef mL9fuPZuqOi9x2FhIqvy1 +#undef md4VXnnHqGZYN9FfEwMCW +#undef mBeVnxVGsv42qh8iauLFG +#undef miiVgeXn417nCjY5ebPhf +#undef mpqi2n0ljngTDl3zfRcZY +#undef mjhYvAnHCo7RqHTG4kGs8 +#undef mfZqF0j4sUltUngd4Hj5Y +#undef mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t +#undef m_mN_FCCplLb1O56UTVl3 +#undef mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR +#undef mY1aayBcuQSa43sZHmeQS +#undef myuvjPnvzcBE3NfHkRLiX +#undef msKAlT0dx6w27y9yHjm3iwlc_YIajMN +#undef mrI60jYuZ1dFPDfd24M0Q +#undef ma8foCOgNMskkXnP7fzWdE7PnvWtDfR +#undef mjYBDnziuBBoR8htpZ054 +#undef mfkiYufvbU5mF9mdgM8ig +#undef muyLCpzNWkiG62Rh8y6QK2T12sisiZy +#undef mSiHrrzr4Y0scm_4uqOCv +#undef mEy_pGq0H0Ns418E2TeZz +#undef mPwyvAQ1wHSSp7FJdoENV +#undef mmFbqqNxE6b68zHtj1L1b +#undef mp9HJBE0E90Wcmb9f9ar3 +#undef mDzGqUDtD5PGwMNxtuRIR +#undef m_5q1OVTkJJKfB_ISHjog +#undef mB9JHSBU95BEjegV45XDO +#undef mWnjTNUFoM25IlGBbi5Sh +#undef mI4cYeHg7cwBYkfBvwQkmssxvPpHCRl +#undef mXAbaapmUexXuxomQ2UOp3r69lu4JB1 +#undef mxRngYN6opotzgq0i2yF0 +#undef mpmCfg6OTFu9ueV1Jvoij +#undef mjAnZdEfD7dHR86j3d92F +#undef msUrKsbZb01INfsQYkuex +#undef mkMSqyZx8knDVKKeQRRAPOPQ1OycFsk +#undef mRENlzQNyEPIksF6cQHQj +#undef mTIqUWMZAhhidB3B7gCmt +#undef mX1lxVUYXutVkZTja3vCylribxHJyyr +#undef mxjH4eEwkhiNcmUP6GEXq +#undef mmFrxzQTWygQiSMiAd1ou +#undef mrWabZl6Yqxhh9lJh_vp9 +#undef mBY9q0vKK0__eH5VQs9_L +#undef mpNsMq_Jsh9rRugWA0zzy +#undef mGdAJfTAuDccsggh4RYB5 +#undef mJSJkb3ccP0_n2Wxy8nWh +#undef mYV98481WEquqd1AECvpqWYdnflE9jF +#undef mO54HUFE7XGVtlHtttmH3 +#undef mNTqpwjT561WC_1cfoCEr +#undef mDTlqiHhmW7Np9mQzo1tz +#undef mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m +#undef muJHokUqtf6fmO3Ky49f8 +#undef mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS +#undef mHiYGul5svZyW_rLyOjTu +#undef mW_kHdhknJnJHqJtLDQ1K +#undef meHoDa0aUmPvFXvZMmfuA +#undef mGQ4ZN1hA5s9kbimw7Qwy +#undef mSa9VlOXwWy20y1aecFml +#undef mMvWJbWSLKEHq4F0uh_XL +#undef mEnhnBFQ3mB4diArixuti +#undef mC6homJJPESbePyDgOny1YcxCcn5QHR +#undef mtAlnZAB81NJEQfKELvkr +#undef mIDgb6uGhToe8NBW6xKso +#undef mu79Z1nsoA2cM_nPkf06A +#undef msAueAn4jz6msdaMAOFvD +#undef maTpexuiU56_wx8NMsDqq +#undef mY5NXKCzp4rf6Ovwtrdxq +#undef mvtZWYnFIFlTMBNRpc3mM +#undef mJmF0v_b2bVzIAj7lN4hw +#undef mnXWkAlgXzCuQoJEu5uiO +#undef mYYc77i0htGEQktG2Neo1 +#undef mC2xaBE9kD4m2EfxxN85e2W5D8psu6d +#undef mnaoSvkmA7uG3CzIf2JLX +#undef mDPHjdm2_QWPyhebFvYkD +#undef mEamAz92Ayua5tQlUuQq6 +#undef mRHVbf6L_uqgqJB68GawV +#undef mdeSRuh1fJRPfCJYIGL3K +#undef mcnZttRQtHTT1zEcTrcXq +#undef mT1Yuv8tLPubZaOzlRCjX +#undef miHgaIOIXnP9MKa_Ynuzb +#undef msWHPNAG9RJ8USwCYjIRg +#undef mb0Jed_XHNWdzUez3EMOb +#undef mS3KOSwoqktmfbJXrTgh30aLzdZFDf5 +#undef mTUb9WYxxxWOpnX_tuW8L +#undef mCEME69o7Es8kNPY_qo8L +#undef muIKgdX84KPh7NwHu9wOb +#undef mpoZNJTEPtCn_II0lswxG +#undef may4T302OZ7loQtO8zrNp +#undef mD1FtOnG5lJAS7VVmL6Ph +#undef mVDeIkD6a7uU0LqFHLuPG +#undef m_TFPk3Phi8ZX86zM0rxV +#undef mRWp04iJpyRq8tILClaZJ +#undef miK0cKKXIJZC11uUUzrLR +#undef mlPYm0vEibuOv_LKABukZ +#undef mnr9KiD3xP6jhiP0klzs8 +#undef mO0FjLQgixFPExZXiYeXr8hk69NoWuX +#undef mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U +#undef mLS7Y36zZso1BwBUg8wDr +#undef mZ4GZ4UmqxVyfyG8CPz5a +#undef ms2dtz7ci8fKKwi4grih1 +#undef mtb4cFqSBOv6HgXSTvrTj +#undef mipMN4mtnGA1X8ocw1VUzyTesbkEBOw +#undef mZMrdS758Yf9PKctFfaYZ +#undef mEb0vgWbp62WJkkmtdPujPWI8EMqsYH +#undef mdHtGBEDt4G4jvY6KOGzW +#undef mwlsAHCjnxf1m2hGk7SPN +#undef miuYLrMna9tTpfuHozSxZXljtr8IWGY +#undef mM2m_2Donhjltd0Debl64 +#undef msKaUi822wPxuzjUtd8Pa +#undef mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ +#undef mzuL30IhryR3NJMszS89h +#undef mRzFXIQ0M4lxEiykp0tGE +#undef mz5kaqHx8JTSTaRfRR3EBitftTo6TW6 +#undef mNDIxtoehMB1oIpVV3LKb +#undef meKZnYzO2FX6PDdko0XJI +#undef mJZTaq8b9U6IHm6Fo0zfj +#undef mJE0OEa9lyhoBhR5JwHj4 +#undef mvxcxvBinAJ8yONOAxeJ3 +#undef mVM77PvnlvRK1mLTKRKei +#undef mmLMfZuLLitP3PNsKn3U4 +#undef mcVfnknnHgJjobEYbCQZb +#undef mlkIT82897HlGwEOzq3R0 +#undef mhp6bWPRQLSMINJFWgnoY +#undef me3HErcslswtnJE5PyQ7h +#undef mUvejUG0VZ6oaFYLfv96Z +#undef mZvFBh86Am0OfcHWSxajt +#undef mzHszbbCS_cUrYyWLxL9J +#undef mIivzJUcx177gxdHt1Qrn +#undef mQHl_ec60ZnTta9Kjat5MnwCDywKP0S +#undef mK5osLCJErLUjdJVDKOO6 +#undef mxQppl_B1tP4_S2CE3A7S +#undef mf45G5P768Ut3IC0WfAVV +#undef mMj_9sE1weayB75v7BdK8 +#undef mYnZwY1qztvF6jEJBoGi_ +#undef mkDBTxQUKyKFjRyQY44KV +#undef mmcgp6Gf_wMHhMWAP3nYZ +#undef muUdW3fqjYEcWW8jBykcma1JP8mjRxV +#undef mjwkyWIKCg9v5IEoO1tb1 +#undef m_iMEsCNnjEITB27sIXurIsGPpif5XE +#undef mjSoZeXICFupmRJnwixfY +#undef mWNZjhCXwY0h77nbnnQun +#undef mdV71Y1rT0MkSZQco4pkM +#undef mPBi7A48_1c_87b1U_Eoa +#undef m_SGFgZqHNGYic2jE2PZs +#undef mrdmCc9Gc3ukvwGoxQggu +#undef mvvmSM3BA2TJMl_6Z9ScU +#undef miJ4T9koNX5tdXmZ5uaAF +#undef mf4r5S0Gz5iK0mQBxOgrA +#undef mIOO9HkLingUB807zdqfm +#undef mwK0gGoxdO620JNMAf8LcWrLXkSVHqY +#undef mCnRkQx6e9t50ErWQAwE0q3YKghcooj +#undef mBsNR7a9eCj4e2paObbgMzu5XwLAjnm +#undef mpwGO7r6CJmc7pyzxPS0W +#undef mJfHf6vHjeGZbDkm_IWNg +#undef mX2uK3ci5pcPqQSvs4amk +#undef mPT1fk20Pr1eQ0YB5sxd6 +#undef mgjLIBeE0wg2QrojbWXXE +#undef ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf +#undef mzZIX41vw1HHV8g5Zis4L +#undef mrzBsv3kMMBOnuA1vQYB0 +#undef mdNNjVkqM2InU1bCHGxmP +#undef mYg2fb_0h62GR73b_cpn9 +#undef mI4sf76lr2ENejiQIjqzJ +#undef mL7RQgXYMf5RjI3gzAmom +#undef mmwuJQME0484L7jN0wNls +#undef mTvuqEbq8QyE7GGDRvvUi +#undef mKiDysFpzxUykXXw_WZfH +#undef mX0mE9NJLZdso_vDht0x6 +#undef mfQdV5_coeVOh0_XAr72d +#undef mB8iHIm9FOE1v4JRokz6E +#undef mRkPOYbSt70qZdeFG7KTU +#undef mM7GbDdkpt2DGNP5IRiPZ +#undef mTva02hxveOfDWDk4eVeg +#undef meLXGbNjy3PRj2YFo8vov +#undef mueL4P4xnm8R1M0bl8Ojg +#undef m_2rFCzuQjnYmj1u2E3Hn +#undef mEqTIrKKpbyOgBfvxq5Uo +#undef mnxqg8Uow3e4hAyXi7IeZ +#undef mPBz2W83ARDLALxh_6rJK +#undef me_oz2FFDkcB79njugEzc +#undef mdwjkxbPv9lRst1GU7ntQ +#undef mDF2umNp7X6oYOD0Lwyy3 +#undef mSpGFgQwHX_r9ijW72OO0 +#undef mYpuIV2wVprROhZ0gZwqQ +#undef mbd03FIo9GTdRlDtujpAU +#undef mjlW6Gr9BKXBEqm9b7AyH +#undef mi4UDYlJVme2p8vz8XCwn +#undef mHc4_w2MgUHx4283kOjz9 +#undef mPkRdGYYZOKBHLvkzvyRk +#undef mwmTl_1WKubaBtbkcxNw2 +#undef mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I +#undef mc64seL8_QSxuYhWboswo +#undef mYhDj2gAIVF7iiyAIzfLc +#undef mxK3g5IVylkgINFWSbxF8 +#undef mlNC5dwEflF9t_I2G7kwV +#undef mjQJF2BhvHcfP6fiRsDi0 +#undef mOxBLp1l2vKYX_rNUj7Fc +#undef mVC71FDKngiAI0dFcsSY9 +#undef mmAL_ct_wC7VA_KqJlBIFYgV6jc5z3G +#undef mkr0aLVnJz5CaZvioiLL7 +#undef mO3uJapBz8hfvZuLXzM53 +#undef md_M7GPITQtDS4BfzU9d3 +#undef mboS9FA2Q220SPFSMGHI8 +#undef mG8z_mtZKC7ZO_NoWacf3 +#undef m_YweHWYbkpdV40mXJspN +#undef msKuhdHIRNOlAQpbiW9KU +#undef mnpE_s7DSpkcZ5cnGnc16 +#undef mJri6232WYf57v7WHLLtJ +#undef mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw +#undef mnvfRccV6sWLKag7QRnMi +#undef mw3w4itcdSwk4YnPuBarj +#undef mkATTEISGOYokIGC8F9la +#undef mi6HZqmh8GILM6LjanUt5 +#undef mc0rMkLpNFfuLuqr7z3oz +#undef mJYXLtUQ27au4beQhf0PM +#undef mhSjwWsm2mahiTUSTjt6nFB03As_xU3 +#undef mSq36Z11XRl1JXoARgKCB +#undef mFIC1mtAi41jxmBTb3wHn +#undef mpfHVtwBeRCF4HzfR5aYa +#undef mM2DCYuIrYsxI9lPkFjQS +#undef mgga0WnnRFtBflQKtpLuK +#undef mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL +#undef mdYtz2htQZh8P7qHU8sOccXiq0Jsbpd +#undef mtnD8HN9EM8B5CF50YpX7 +#undef msKlRUq0xcK7JxZyasKkH +#undef miNE679CW5B3xxrVDrvN9 +#undef mUsuCEIFvRP_D44KPaQY47o4ispy8Vj +#undef mpaSqCpDpGH0eULjahGpg +#undef mqVF9yhdjkvJZAJPGWq3E +#undef ma2vK_VeaV2yOivBMAaS1 +#undef mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG +#undef mNUuCaMUS8zqfbXCimtgj +#undef mrtb_bhYbXTw3XOs4vV1F +#undef mXggdfMCbAbSH20gXjoXX +#undef msVNRLVmFBztOVESz5AQJDfnqtqgN6L +#undef mS6JTMBdIbEJgKM_vQoSK +#undef mGQgYgclze4X2bB4vpuzW +#undef msn15RJjYb_SsaErIfRNo +#undef mc8ipMXPIMdxjmKKG4E6NKlqXdYMncM +#undef mGXDvm2ZdrqugaoZ1YccvqzabYqkG2k +#undef mtawfM3ndXCRasZXQxRrp +#undef mhgnRFmDEM5LAURVG5y1L +#undef mfJjRpXi94twT9pqD5JVX +#undef mW37fLe5jzVXLk4yUjj24 +#undef mbubCLceOr5QXaiOQQPP1 +#undef ml8k79uncra_1jDk9y35b +#undef mS3cOaukxo2FRb5RvHVc4 +#undef mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL +#undef mnfv75cfRX5nwn_P3W2SZ +#undef mcq33jn33ngPvU8ExIgnf +#undef mS5WCLZvcR3iydjHqSMii +#undef mQFDOegAOguDVHU3KoIJH +#undef mGHOYAWjopscrujOCjpSi +#undef mBdKtki5i5z_rqVGrRUtu +#undef mBliNpjYGnOcf7SuCUXfw +#undef mcX71Wu1NrgiE1PjmF5oW +#undef mzJn2Y5MSTbpYun9rdOSq +#undef mwoHtFc7XtGdE5RWuAZoG +#undef mBf0JMOxQ3sCg9N87xsxR +#undef mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH +#undef mHt2jDj4LBpP36tiW9beq +#undef mHp07MIs1jIqbiHORNZtD +#undef mGeAkoUhfYDMrrSVlPr1O +#undef mwgU_GguJtAB5Bb35MdwyMTlNysOLJW +#undef mlxwRZWmFsIX03zy3tTy0 +#undef mgIg8CedmHvBkJNohUblZ +#undef mSNCcmKF29PRGlI8Tdwja +#undef mBzApfw9R5DW809yw9n5C +#undef mk7ILvvJtbDBhzuKjuFuZ +#undef msTibML7U5XAa62kfYMyXMMaQgK7wvx +#undef myMbdRujQRRGxZa_esh6OHxPU22Olyw +#undef migdvOq5L79sWQtwLyhs2 +#undef mIkusqIJdd_o34vSBgzWv +#undef maFw6BG67rqfttMYNKgoNemSsvLkQYa +#undef mBx7lmwJEgh_boAo7hHD4 +#undef mvt_8yQ6OWmKTfvk3dzq1 +#undef mfPiMJHfWML2WymRvotni +#undef mZFd_wzPmPRc35lEvSHE0CiTnEdVk2C +#undef mVzsLDeS8SOv0E6YGFv8j +#undef mfvMoVhY8cjuWRUJI73Pl +#undef mSkMsyd_G4SVpaKFDM3Uc +#undef mI1ri11eHWS0GoQQjfv_u +#undef mLp87BNpaRa8bU3QE39AH +#undef mTzlvPwOAcxvFnaU7tzec +#undef mcLZRXidREDnQsUILaskKBiM_OAG8ua +#undef mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC +#undef ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI +#undef mPQkyiUN1BvHTMgAxqODe +#undef mMbu3hdPmJMPrM_d1Cr0s +#undef mtehHpUuknvUTAKK7BNgA +#undef mqefKqLpc5MfNVAgzWWfC +#undef mobX070S3wO6zxczaIZzQ +#undef mZWm2nGx_Hxwoni8yg8Qj +#undef mj0SmRpcdB2TRl5kdNdBQnXpbI2PaTI +#undef mzRXDilasYlw5CVJtdYdM +#undef mtPeORXsOWhCCSWRotXA_ +#undef msNlLNhq5GN7XcbzwivI3OWPTWt9svc +#undef mjE2XFXDR2hHCf8IsA1BO +#undef mLwLUP6KZ9PRisEeZakem +#undef moj9aYgB8JD1AgO4ICT3d +#undef mpQACTL4b3pHMD127IZSN +#undef mKHRSL6QRz79M7iwb3xFq +#undef mnfIFXb2Z55p5DNBveqbx +#undef m_QEZZ3iahWFpeO4whzWo +#undef mud4sr7JVgGG6yDxhsQoI +#undef mQk_FiTqfT2quOMiM0cIKgE508p48JO +#undef mWw8FPQaCI3gn0wUVEyTI +#undef mhsPoKPzVdLpxSkCW6gM8 +#undef mR5JEG117hlb3MtJMpeEA +#undef mhK2Qbp1bwBdQQlO7M8sI +#undef mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3 +#undef mv_JVFkODVRLTSkXzNmRAFyoFoAzy3J +#undef mWrGjq0Squbg2ySQrv2yy +#undef ms8ohDxwnrSLtbOpBsiBn +#undef mxODpvgncxHDxAXg0nTxi +#undef mpxNV0vBtyYJsCSJulyLm +#undef mkvvczg0if8KqjNRfebjz +#undef mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr +#undef mF7PjcGzXBfuvYPxX4ENs +#undef mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk +#undef mmwMxLCLCS3PUrkR0S4GT +#undef mPBqMiL37DrIolFnluMjB +#undef mi0l_sHwUblCkb4iaLokRozuEWNdBw6 +#undef meHoni3WXkzVpE4d0kmI1 +#undef m_BrEaPHfim2E9yF6_ZvY +#undef mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E +#undef mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz +#undef mahSq6rrq2neTeBW0KH49DPaFsniYhL +#undef mXx9mzEZ3WuXitLsCMbS3 +#undef mhen8iRk76Q4ezN_ZTavu +#undef my9HJ8yK6DJjsZPdzWxZL +#undef mwUUBDVL49RrRRTgyVPVN +#undef mKEA1BZI3NTi8QvqudEdc +#undef mEwcSf6xJjokt5SShXKxS +#undef mohUEWtGNSJiaUfYS_hHU +#undef mo9UqUd0NMYxMbXiBpNmp +#undef mEfdpZW8Tgwkni5sEouU7 +#undef mG0XPjV2nZH5rw34_jjn_ +#undef mtPVppy1yz0JrXtPdjMoW +#undef mazMo2N6FXwsNwoWMaXmw +#undef musqt3SUnZXONhXx36QTM +#undef mm4diUXyy908ilcG8VsiM +#undef my6ztJkSs2s9dWfJOJksF +#undef miU1_742S5SYXnR5Jx89T +#undef mUAT7RqwcWJKHzYQUCA0y +#undef mwjNmdVvS8bIC25sTrclB9dCibfRKDx +#undef mncmpqNhIup2FdHbcG_I7 +#undef mvVwZIT9LYdLjcMYjL6fQ +#undef mRtNeoipHh1bU1f1bmWPX +#undef mVMtoBTx7Atu07C1zpSOZ +#undef mM7P5mMaG1l7fxkX3FWCT +#undef mGfToHPBdGgajCf_jjGO8 +#undef mMJxQ0EBp3m14gB2r3xIc +#undef mbldl9dwMrRmnA2YXgRup +#undef mCw9yl5OPmGbIXjCTLMgT +#undef mdcqBUCL5eOKU9PVtHvug +#undef mEl0x2A3ElD6IIGxgIMh1 +#undef monM9oNPqUFsPMMVWOpTatnkGAmgDe9 +#undef ma9kV7iftDKaJMwPMmic6 +#undef mFr9xKf_e_bmCOLt2lDD4 +#undef mHN4QkSpFuhZZROE3e75ST2ernStapx +#undef mfoiPdsHJ12pw0fAmu2LO +#undef mLEPndrD0EDs3kVH87Dc9 +#undef maDHAuramjTITZ8BkVyc3 +#undef mZAlRw_vXw7OrhwXXa1s2 +#undef mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df +#undef mTijFbkuqZobez4o86GTR +#undef mw_8xZKbKGnlYQNGWwE_0 +#undef mjtgzOH8_fFDjnCUIvpJR +#undef mcmEFUHvzwZHvsOYCgnyC +#undef mnCvMc73RamSZ8lE5SaXG +#undef mDe6Xdhfu94h0bVchSL24UZegztDHht +#undef md4LgblW399NKaEPBAY3T +#undef mxbbdZ8472z3S1r1q5ZWj +#undef mvvQZKXqZ3gS6vWzM21uf +#undef mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr +#undef mzAWY6BVbyF5XGfs95ZTo +#undef mvVntD47RvCRRdFhEAzH2 +#undef mnaeVhufQTwT_lV4TnsPF +#undef mo5687q03mFTCWmTFL22s +#undef mnv3HCmWHbNAEwSFeikW_ +#undef mr4zczxVHQA3dSD8whfSj +#undef mFR2AYMAMdlvPHNClNuuI2P2lzdelpy +#undef mniKBlIuV5usw0rljtOxS +#undef mfaBCDA_1mB_o1gczVteCCzLS9jytzz +#undef mXPig4KjJlLryx1k7a1qv +#undef mj2vTnvmJGQRTP74fz5th +#undef mcUjff6jaamQlwbiN5lMFGZa5CWNEQt +#undef mKD4UGvYqSH2GIcVJ2xVN +#undef motTJdCC_9geof6XxtOIX +#undef mZi7qi6srAkaKViRVPr2V +#undef meEZS3fP7SPnS8S1IqEmR +#undef mzb0bJuSjJhlivJIz_rfW +#undef mSG4W65NNIcornxP1sDch +#undef mdE1fJK3aKa1btI7OCyNv +#undef msecMYaXfF46rGGcWJxuScGlv8bYIpo +#undef mZKQBVu9NPSaSKDvETZgYMQILvBIUsb +#undef mP769HJIua8m0mI4ktrOP +#undef mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct +#undef mbMIBvXxQ4fdNXtBFULCa3sGjseDD_9 +#undef mcLleLW3WGZ6MsFjWUfct +#undef myyCsm1QzAMbV9FeubYLY +#undef mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ +#undef mgKv64TnJJRtHXBTzACDO +#undef mKzklEw5IRgQmI3OSml1i +#undef mN6OdwmNUVjXUhxmeGf8J +#undef mM1pbAJE40pyDAsPbwwMd +#undef mnFcnzhSc68PBY18KNbo7 +#undef mDpKPA1KOuuQehqrHJtsl +#undef mIivpa7B9YEutjvbp_HF0 +#undef mampM4g9ObUpU_xCDEpgQ +#undef mS_3jX9nIMiDQ3_4oIDIrZqK46910cN +#undef mWlw_t5LZEaqBm9_nt0iD +#undef mf9Cutcm6ImnorHVFDeuP +#undef mK2i85pgNdUMagXTmWJ5e +#undef mB9YvSPWz0tX4EZ0kP3Cu +#undef mhCwMg4Ffjrj3yXjOd5fx +#undef mlgPh47K_7EW2ZXBliaid +#undef mbSdXRep8t2vTB1sedPyt +#undef mjKxwUdMxuMgV0dkJGEp3 +#undef m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG +#undef mmAweGjgflL1M_L8xxbS5 +#undef mOMfyQeUFCcsFk8Ad4BBL +#undef mQJ_ov46f8fAit991t8gf +#undef miUNNahIhqkHJ0O8mc7at +#undef mVt0bbujrHNetZKOtuKde +#undef mmombSefdt4OQYXhCimSX +#undef mc5fxBzrSgunvzSKuEhwj +#undef mP8SrQcdiKeneTPj3ncar +#undef mkcMJUPYZgJAtwAWvs7Py +#undef ms5n8S6sLK4BKl5mCpbvH +#undef mLY18NKQFABTYUMkJm2SH +#undef muHYdZsjdFUoHAvBLvUVe +#undef mdinLDLM5O6qM2Iua48QL +#undef mZZ26QMzJc_5LIwefugPz +#undef mKo7Dekr2hkVH6Q2yj4v1 +#undef mJSr1xT3rjrluqpa47g9Y +#undef mNqyOa6KdCv6zSr90UyAl +#undef mRW5kEFZa1NALZX28ZIon +#undef mF6LKJaZ8E_RFGqer3CEP +#undef mnXffFztl_Q3mHTMfL6Um +#undef mOnkdM0WujiddAefb4ESe +#undef mj5ixplkQLbcxKyYSRwxy +#undef mqQ3hcKeFeE4oJoHQSvf1 +#undef mtd2U4uO5qMUqFSFlA3o0 +#undef mtJxJU59f1eEFMiVPqSOd +#undef m_18997e8JQQFco5N9dHK +#undef mpxo8NMrHzok0zxZzo_cs +#undef mCuRJqKBRH_BrOMv7hXsF +#undef mmxmIMH7MAnuDJTXb23zQ +#undef mzjX0iRvCYGhZO2ITjcdt +#undef mJFezRZdF9Yll4E2ofN_f +#undef muxvLfj1z4AXZePUs5M4p +#undef mXUy3srwASbKuClu_vKTe +#undef mpEgibffzQXRDDGDQaUGA +#undef mrmdYuYTVzarkSFRATlha +#undef moPdQYooVsM15VAazKOEZ +#undef mhdOIl9dw0JQwDi0Ir2lO +#undef mSokNq3Jcm0CZDZY30Wno +#undef mVtH44jy_Eg0rghDYlMs4 +#undef muSdZAgzhs5ln2vx_pg0w +#undef mrFprXhaW2MYwjyrlnlK2 +#undef mgx_Aav0AEvullRtJttF0 +#undef mQxZ9x1jAWoPY956fLMm7 +#undef mZJOXxx7hbtRSTyy_HjGF +#undef mpSLr9wROWvnZD1iCdovU0nYZFqKrnP +#undef mMmBs0INu0k5X_FJkD5rr +#undef mOj2NZtBCgsNkYM982aS9 +#undef mxYncMrtXC6SeU1ddoChMqio0cqvklg +#undef mXqVbRWnIXdf8unNXdsWn +#undef mEyjl8Y5Ko8WIO7rc8xjy +#undef mJXr69rhzcs2uHnnZc46T +#undef mAw0cMDkuY7VauTjR_gzc +#undef mz5lesIyi7JO6NQ42HCAr +#undef md2kXkeBxboEMBU2AV_5s +#undef mJ7GYjgHHCxtWCUXtHWVv +#undef mj8J6mUMVIiLNPC32AT2p +#undef mhOJP7GTKtZVREYuK8qsM +#undef mk0UDRIyOODBYPpNMMtOc +#undef mqiIIc9pe1gpl3JSjqxBusmApaww4OM +#undef m_WYn2n0wuk6UJ5kGIQak +#undef mVx2i0xDty6d7wAQ1AEDX +#undef mBS2ISVIhJublZPH29E0a +#undef ml7ROdNRafN054xhICX2X +#undef mH81SrGjFrRCXYSiJnoqa +#undef mqed_EcKcpv3tmsK0VwPq +#undef milR3XNnU1JDeN9uyM761 +#undef mfKuHXwnr7XBA7NCf6pZq +#undef mB9eufg8BrcMQwsjy5WF0 +#undef mhW30YVZKc88sPKpBl_boHwzPPBIBGD +#undef mCi4vAHb8oVMCZWxLATzD +#undef mU9sM0kyDLaDRi1mqQV4j +#undef mjn2WKwnpSiVmCWLEjQ5k +#undef m_1J0sGT1PB0ZSBudKlNA +#undef mMa_6lMFLoFYPgu9fRTI1 +#undef mUp9jH_JJkeWGYg6SPvxb +#undef mUALbycuQX8qqtu56NWoaUnZ2ADJjRh +#undef mM5M87hxO0F1jykbMUggh +#undef mAtxCmnHMZ_ygb82QGCWO +#undef mC8ZaJ0GcET6ctFrqYRmP +#undef mrVo1fO7oMN0F0LcGmw_f +#undef mzz466vkULaDwnx05qd82 +#undef msRO7__IOXu6L3zcMPeT2 +#undef mD_3HKaGheLWoKIFvCH3L +#undef mtWQnh_W_PD5ev5w8AW0s +#undef mbtyTfpzqoLMszlSfGVhS +#undef mzrwOkaVNQ12qikoacOtS +#undef mAFNVBR8qnAMnJsIDO9nA +#undef mWDsKNjyxVW4J9q1AwGWq +#undef mIUF5GxYrg8aIVgkWNnBb +#undef mYB0YoRP6itbUawfbPusv +#undef mOf9_wb83eei1ZBzVuOZTTfg41x_5sS +#undef mBojQqzqPJA0Zhe79JerpswyOrVuQps +#undef mcupMgy1yB7mIget2eDow +#undef mKlU2t7ATzFQCzp03OHXo +#undef mDk1S9vejmO23nQ14m4JM +#undef mPRf5NpGuq6ZoBfArKDF3 +#undef mYoowvicaALAqcfmGrsSD +#undef mMz0if0V8wBaqTUtqkPem +#undef mZnWOcG4IZ_M_1uOVr1vf +#undef mIpgSd4v5yWrnWkLSTFr4 +#undef meadcZiQDrRuC0Tmbyyiu +#undef myLMH58GbSZSEKIADq_9T +#undef mypwvI9nBVxZQoSRivBsz +#undef mslakBBg5XJ6k0ROZMh_4 +#undef mcBOeh7kvkLdVFdML_waY +#undef mnW6ZFYawWAWMCKpMfvE2 +#undef mIyJPGeEvtQe8SOesQr7v +#undef mwfChnZD0dWqo90jpqN70JK8Mo9I5VD +#undef mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj +#undef ms9M5EwDiWgRYZIdzQWmp +#undef mjVu1VPVfft6_jPiz3Ec6 +#undef mHW6nVkC5JlKM0bwQFsqA +#undef mkLql5eCbkw_VBW_BfUxp +#undef mQs7VG4JKWIimbZO9fFo8 +#undef mJjl5sA9ehjIzAWdStIFU +#undef mdcIh6lew75dFEC4p3Q1h +#undef mknpWNnES4R_63cdbcdXV +#undef mUvbKcsz8i4H1kuQe8W_B +#undef mmDRiATwYsXZG1Jku9FPg +#undef mEvpZvX3Pr_xoJcbIft169GSIJ4Uo3B +#undef mkYawy3Jp4pgcXnw3fgN3 +#undef muPhaubkj3SDNA5Wasshg +#undef mwPsLKrAzq4RklpopaEAw +#undef msgGhTpJsjlaQFml28rg7 +#undef mWjTRicytZl2oVzkUTdvq +#undef mgeGMjcucDsavdvBBcXoD75__Tb01sm +#undef maNkjFQf7KL90cn5vbMa3 +#undef mR3g6IaCAGZgxHIA8qCxW +#endif + +#ifdef _6580636470966009790 +#undef mjYBDnziuBBoR8htpZ054 +#undef mdHtGBEDt4G4jvY6KOGzW +#undef mi_O6EJNt60DZGoXx1wHw +#undef m_SGFgZqHNGYic2jE2PZs +#undef ms8ohDxwnrSLtbOpBsiBn +#undef mWlw_t5LZEaqBm9_nt0iD +#undef mkLql5eCbkw_VBW_BfUxp +#undef mslakBBg5XJ6k0ROZMh_4 +#undef mPRf5NpGuq6ZoBfArKDF3 +#undef mUCUowYS5Zgxsf8jGgVp5 +#undef mXUy3srwASbKuClu_vKTe +#undef mMbu3hdPmJMPrM_d1Cr0s +#undef mBzApfw9R5DW809yw9n5C +#undef msKaUi822wPxuzjUtd8Pa +#undef mzb0bJuSjJhlivJIz_rfW +#undef mUD4rGlgxQjbo0JVuke3q +#undef mOxbZipdUMUjuuBjccJiL +#undef mL7RQgXYMf5RjI3gzAmom +#undef mrdmCc9Gc3ukvwGoxQggu +#undef mZFd_wzPmPRc35lEvSHE0CiTnEdVk2C +#undef miNE679CW5B3xxrVDrvN9 +#undef mBliNpjYGnOcf7SuCUXfw +#undef mpwGO7r6CJmc7pyzxPS0W +#undef mPBi7A48_1c_87b1U_Eoa +#undef mp9HJBE0E90Wcmb9f9ar3 +#undef mVzsLDeS8SOv0E6YGFv8j +#undef meLXGbNjy3PRj2YFo8vov +#undef mJXr69rhzcs2uHnnZc46T +#undef ma9kV7iftDKaJMwPMmic6 +#undef mQFDOegAOguDVHU3KoIJH +#undef mvVwZIT9LYdLjcMYjL6fQ +#undef m_TFPk3Phi8ZX86zM0rxV +#undef mnfIFXb2Z55p5DNBveqbx +#undef mTzlvPwOAcxvFnaU7tzec +#undef mG0XPjV2nZH5rw34_jjn_ +#undef mC6homJJPESbePyDgOny1YcxCcn5QHR +#undef mpSLr9wROWvnZD1iCdovU0nYZFqKrnP +#undef mDzGqUDtD5PGwMNxtuRIR +#undef mvt_8yQ6OWmKTfvk3dzq1 +#undef mdwjkxbPv9lRst1GU7ntQ +#undef mwjNmdVvS8bIC25sTrclB9dCibfRKDx +#undef meHoni3WXkzVpE4d0kmI1 +#undef mv_JVFkODVRLTSkXzNmRAFyoFoAzy3J +#undef mnFcnzhSc68PBY18KNbo7 +#undef mFR2AYMAMdlvPHNClNuuI2P2lzdelpy +#undef mBdKtki5i5z_rqVGrRUtu +#undef mAtxCmnHMZ_ygb82QGCWO +#undef mPT1fk20Pr1eQ0YB5sxd6 +#undef mLwLUP6KZ9PRisEeZakem +#undef mDNXBsrSCyjZ8H5TqHKE8ydryKS6POH +#undef mrzBsv3kMMBOnuA1vQYB0 +#undef mo9cHp1NOYwzHudST5ct_ +#undef mdcfBxuY9ca1Je2VwDSgUMxqgXDgPST +#undef msKlRUq0xcK7JxZyasKkH +#undef mHLQwCfYwfpxwbMKqQaK9wJFD8dMYzZ +#undef muPhaubkj3SDNA5Wasshg +#undef mWnjTNUFoM25IlGBbi5Sh +#undef mqItj5mkpzJ38jgqpOkYj +#undef mVC71FDKngiAI0dFcsSY9 +#undef msKuhdHIRNOlAQpbiW9KU +#undef mNqyOa6KdCv6zSr90UyAl +#undef ma2vK_VeaV2yOivBMAaS1 +#undef mu79Z1nsoA2cM_nPkf06A +#undef mZMrdS758Yf9PKctFfaYZ +#undef mMJxQ0EBp3m14gB2r3xIc +#undef muHYdZsjdFUoHAvBLvUVe +#undef mY1aayBcuQSa43sZHmeQS +#undef mgKv64TnJJRtHXBTzACDO +#undef mJsIWgoWyKz7gM1eewOxPdqTEsPl2JS +#undef mAnJimC6YgR8qvnQB7ZMP +#undef mBeVnxVGsv42qh8iauLFG +#undef mSa9VlOXwWy20y1aecFml +#undef maputXWpuSswTuxiye55G +#undef mMmBs0INu0k5X_FJkD5rr +#undef mgIg8CedmHvBkJNohUblZ +#undef miHgaIOIXnP9MKa_Ynuzb +#undef mcvDrOWJhA_Jj9rADu5RY +#undef mcq33jn33ngPvU8ExIgnf +#undef mIOO9HkLingUB807zdqfm +#undef mK5osLCJErLUjdJVDKOO6 +#undef mSG4W65NNIcornxP1sDch +#undef mJri6232WYf57v7WHLLtJ +#undef mYZySka2r5zYAEO1eOB6HyYTMPAnfWX +#undef mP8SrQcdiKeneTPj3ncar +#undef mncmpqNhIup2FdHbcG_I7 +#undef ms9M5EwDiWgRYZIdzQWmp +#undef mzJn2Y5MSTbpYun9rdOSq +#undef mAFNVBR8qnAMnJsIDO9nA +#undef mHW6nVkC5JlKM0bwQFsqA +#undef mEn6ezpXymeCgJNVz3lrW +#undef msVNRLVmFBztOVESz5AQJDfnqtqgN6L +#undef mtb4cFqSBOv6HgXSTvrTj +#undef mM2DCYuIrYsxI9lPkFjQS +#undef mdcqBUCL5eOKU9PVtHvug +#undef mxYncMrtXC6SeU1ddoChMqio0cqvklg +#undef myyCsm1QzAMbV9FeubYLY +#undef mX1lxVUYXutVkZTja3vCylribxHJyyr +#undef mz4tZy0GWrUESNULCSRoF +#undef mhdOIl9dw0JQwDi0Ir2lO +#undef mTva02hxveOfDWDk4eVeg +#undef mnaoSvkmA7uG3CzIf2JLX +#undef mIDgb6uGhToe8NBW6xKso +#undef mmFrxzQTWygQiSMiAd1ou +#undef mBojQqzqPJA0Zhe79JerpswyOrVuQps +#undef moPdQYooVsM15VAazKOEZ +#undef mySr_PmNqnsLYHdYvB_ZN +#undef mc0rMkLpNFfuLuqr7z3oz +#undef miK0cKKXIJZC11uUUzrLR +#undef mBWTdhPS4d6WQTxWw9qTj +#undef myLMH58GbSZSEKIADq_9T +#undef mgga0WnnRFtBflQKtpLuK +#undef mk7ILvvJtbDBhzuKjuFuZ +#undef mgheRgcIL9OpKtLQ4r_15 +#undef mJmF0v_b2bVzIAj7lN4hw +#undef mJ7GYjgHHCxtWCUXtHWVv +#undef mmcgp6Gf_wMHhMWAP3nYZ +#undef m_1J0sGT1PB0ZSBudKlNA +#undef mSkMsyd_G4SVpaKFDM3Uc +#undef mCi4vAHb8oVMCZWxLATzD +#undef mkcMJUPYZgJAtwAWvs7Py +#undef mRte7PZJP6iITCO2uVu0v +#undef mhCwMg4Ffjrj3yXjOd5fx +#undef mf9Cutcm6ImnorHVFDeuP +#undef msTibML7U5XAa62kfYMyXMMaQgK7wvx +#undef mwK0gGoxdO620JNMAf8LcWrLXkSVHqY +#undef mdeSRuh1fJRPfCJYIGL3K +#undef mmwMxLCLCS3PUrkR0S4GT +#undef mO3uJapBz8hfvZuLXzM53 +#undef m_QEZZ3iahWFpeO4whzWo +#undef mtrAzdiCeLhU7rVrgKDnJ +#undef mcLleLW3WGZ6MsFjWUfct +#undef mvtZWYnFIFlTMBNRpc3mM +#undef mtPVppy1yz0JrXtPdjMoW +#undef mgx_Aav0AEvullRtJttF0 +#undef mqiIIc9pe1gpl3JSjqxBusmApaww4OM +#undef mqVF9yhdjkvJZAJPGWq3E +#undef mLY18NKQFABTYUMkJm2SH +#undef mpEgibffzQXRDDGDQaUGA +#undef mQxZ9x1jAWoPY956fLMm7 +#undef muIKgdX84KPh7NwHu9wOb +#undef mIjc5w7s_Et8N6PxoZDjKMd0Bwsssjk +#undef mAAF1hNrBlLEg80wAcv2c_FQ8jbfnjr +#undef mWC1nvfQRFJLqJcGHQd_DZVW3mGXmA3 +#undef mpoZNJTEPtCn_II0lswxG +#undef mb0Jed_XHNWdzUez3EMOb +#undef ms2dtz7ci8fKKwi4grih1 +#undef mUALbycuQX8qqtu56NWoaUnZ2ADJjRh +#undef mJFezRZdF9Yll4E2ofN_f +#undef mKOkOykCmuX5Cu4t9gb85 +#undef mOj2NZtBCgsNkYM982aS9 +#undef mEwcSf6xJjokt5SShXKxS +#undef mWDsKNjyxVW4J9q1AwGWq +#undef mkDBTxQUKyKFjRyQY44KV +#undef mmDRiATwYsXZG1Jku9FPg +#undef mtJxJU59f1eEFMiVPqSOd +#undef mUvbKcsz8i4H1kuQe8W_B +#undef mFr9xKf_e_bmCOLt2lDD4 +#undef mjwkyWIKCg9v5IEoO1tb1 +#undef mGeAkoUhfYDMrrSVlPr1O +#undef mcnZttRQtHTT1zEcTrcXq +#undef mB9eufg8BrcMQwsjy5WF0 +#undef mF6LKJaZ8E_RFGqer3CEP +#undef mrzgvRTlrhSOpRG6AjzDZ +#undef mdcIh6lew75dFEC4p3Q1h +#undef mo9UqUd0NMYxMbXiBpNmp +#undef mHp07MIs1jIqbiHORNZtD +#undef mBS2ISVIhJublZPH29E0a +#undef mboS9FA2Q220SPFSMGHI8 +#undef mY5NXKCzp4rf6Ovwtrdxq +#undef mYnZwY1qztvF6jEJBoGi_ +#undef muxvLfj1z4AXZePUs5M4p +#undef mWjTRicytZl2oVzkUTdvq +#undef mfvMoVhY8cjuWRUJI73Pl +#undef mKo7Dekr2hkVH6Q2yj4v1 +#undef mcUjff6jaamQlwbiN5lMFGZa5CWNEQt +#undef mRENlzQNyEPIksF6cQHQj +#undef mcBOeh7kvkLdVFdML_waY +#undef mWNZjhCXwY0h77nbnnQun +#undef mQk_FiTqfT2quOMiM0cIKgE508p48JO +#undef mQJ_ov46f8fAit991t8gf +#undef mXggdfMCbAbSH20gXjoXX +#undef mC2xaBE9kD4m2EfxxN85e2W5D8psu6d +#undef mCnRkQx6e9t50ErWQAwE0q3YKghcooj +#undef mhp6bWPRQLSMINJFWgnoY +#undef musqt3SUnZXONhXx36QTM +#undef may4T302OZ7loQtO8zrNp +#undef mnXffFztl_Q3mHTMfL6Um +#undef mTijFbkuqZobez4o86GTR +#undef mMz0if0V8wBaqTUtqkPem +#undef mTwuuBw4FVjERX9Kj4nHaPm6uu60qfG +#undef mjhYvAnHCo7RqHTG4kGs8 +#undef mYYc77i0htGEQktG2Neo1 +#undef mc64seL8_QSxuYhWboswo +#undef mwfChnZD0dWqo90jpqN70JK8Mo9I5VD +#undef mRW5kEFZa1NALZX28ZIon +#undef mNDIxtoehMB1oIpVV3LKb +#undef mK2i85pgNdUMagXTmWJ5e +#undef mX0mE9NJLZdso_vDht0x6 +#undef mNrsNMyOlNPO0p0HXQMMP +#undef mf45G5P768Ut3IC0WfAVV +#undef mmAL_ct_wC7VA_KqJlBIFYgV6jc5z3G +#undef mKzklEw5IRgQmI3OSml1i +#undef mpxNV0vBtyYJsCSJulyLm +#undef mXFkM4J3s4f82M8sIpw0dlpB1pIHCoj +#undef mhsPoKPzVdLpxSkCW6gM8 +#undef mkATTEISGOYokIGC8F9la +#undef mjVu1VPVfft6_jPiz3Ec6 +#undef mpaSqCpDpGH0eULjahGpg +#undef ms5n8S6sLK4BKl5mCpbvH +#undef mJE0OEa9lyhoBhR5JwHj4 +#undef mdE1fJK3aKa1btI7OCyNv +#undef mC8ZaJ0GcET6ctFrqYRmP +#undef mP769HJIua8m0mI4ktrOP +#undef md_M7GPITQtDS4BfzU9d3 +#undef mBLRiQHoNzLxRWkGYEfWiYCkPDY_6df +#undef mSokNq3Jcm0CZDZY30Wno +#undef mVt0bbujrHNetZKOtuKde +#undef mmLMfZuLLitP3PNsKn3U4 +#undef micFIwqBc9QQUuQXqGKWC +#undef mMTPZX5XrdbPaKZELXXWh6Yq_et2CdC +#undef mIivzJUcx177gxdHt1Qrn +#undef mw3w4itcdSwk4YnPuBarj +#undef ma5pnAoZZ1hw38rbzLH0SYNWacPxCZI +#undef mhW30YVZKc88sPKpBl_boHwzPPBIBGD +#undef mB8iHIm9FOE1v4JRokz6E +#undef mM5M87hxO0F1jykbMUggh +#undef mbMIBvXxQ4fdNXtBFULCa3sGjseDD_9 +#undef mPwyvAQ1wHSSp7FJdoENV +#undef mcQnVmzr6nFLeJwKeC5qxiKBjnGtrUF +#undef mz5kaqHx8JTSTaRfRR3EBitftTo6TW6 +#undef mb6FIaRd_qia8_U10282s +#undef meEZS3fP7SPnS8S1IqEmR +#undef mIUF5GxYrg8aIVgkWNnBb +#undef mtE68lB7HxwArLgdxpcJw +#undef mw_8xZKbKGnlYQNGWwE_0 +#undef mnvfRccV6sWLKag7QRnMi +#undef mG8z_mtZKC7ZO_NoWacf3 +#undef mcupMgy1yB7mIget2eDow +#undef mmxmIMH7MAnuDJTXb23zQ +#undef m_mN_FCCplLb1O56UTVl3 +#undef mPBqMiL37DrIolFnluMjB +#undef mKD4UGvYqSH2GIcVJ2xVN +#undef mtd2U4uO5qMUqFSFlA3o0 +#undef mxODpvgncxHDxAXg0nTxi +#undef mM7P5mMaG1l7fxkX3FWCT +#undef mWw8FPQaCI3gn0wUVEyTI +#undef msn15RJjYb_SsaErIfRNo +#undef mDF2umNp7X6oYOD0Lwyy3 +#undef mGfToHPBdGgajCf_jjGO8 +#undef me3HErcslswtnJE5PyQ7h +#undef mqjvrjxD0U1jONB_TZFW5 +#undef mQHl_ec60ZnTta9Kjat5MnwCDywKP0S +#undef mVx2i0xDty6d7wAQ1AEDX +#undef muJHokUqtf6fmO3Ky49f8 +#undef mz5lesIyi7JO6NQ42HCAr +#undef mJjl5sA9ehjIzAWdStIFU +#undef mlkIT82897HlGwEOzq3R0 +#undef mEamAz92Ayua5tQlUuQq6 +#undef mFvI1mt5pDPKVUSHYBtX_CkNEZIhE7I +#undef mwPsLKrAzq4RklpopaEAw +#undef mbJN2L3pYaj75B2vd0RZrC1ie3MEUEQ +#undef mD1FtOnG5lJAS7VVmL6Ph +#undef m_2rFCzuQjnYmj1u2E3Hn +#undef mSfj74s5uEvCOzi1TqmTv +#undef mi2cnitf6XjPI_AR9JqyRxdTxSVUD1m +#undef mrmdYuYTVzarkSFRATlha +#undef mnTomnUfxbEgN2pcyh4IC +#undef mhK2Qbp1bwBdQQlO7M8sI +#undef miUNNahIhqkHJ0O8mc7at +#undef mRtNeoipHh1bU1f1bmWPX +#undef mhROwJUrnW6RV5u5uX1p4 +#undef mMcsTdeZl6dJT8lXT7C9j0AbQQMhSjw +#undef miuYLrMna9tTpfuHozSxZXljtr8IWGY +#undef mwlsAHCjnxf1m2hGk7SPN +#undef muUdW3fqjYEcWW8jBykcma1JP8mjRxV +#undef msNlLNhq5GN7XcbzwivI3OWPTWt9svc +#undef mVtH44jy_Eg0rghDYlMs4 +#undef ma2JuVH9cwa2PZWXEX2RFlL97Fd56Uf +#undef mAXRt0DC6duEWgvgkLnB3 +#undef mLp87BNpaRa8bU3QE39AH +#undef mU9sM0kyDLaDRi1mqQV4j +#undef mpmCfg6OTFu9ueV1Jvoij +#undef mpxo8NMrHzok0zxZzo_cs +#undef mnW6ZFYawWAWMCKpMfvE2 +#undef mc5fxBzrSgunvzSKuEhwj +#undef mjKxwUdMxuMgV0dkJGEp3 +#undef mXqVbRWnIXdf8unNXdsWn +#undef mO2X7vyyKruryPTrlfgIx +#undef mM7GbDdkpt2DGNP5IRiPZ +#undef muyLCpzNWkiG62Rh8y6QK2T12sisiZy +#undef mIyJPGeEvtQe8SOesQr7v +#undef mdinLDLM5O6qM2Iua48QL +#undef mZnWOcG4IZ_M_1uOVr1vf +#undef mEfdpZW8Tgwkni5sEouU7 +#undef mtnD8HN9EM8B5CF50YpX7 +#undef mOxBLp1l2vKYX_rNUj7Fc +#undef mSq36Z11XRl1JXoARgKCB +#undef mI4cYeHg7cwBYkfBvwQkmssxvPpHCRl +#undef mYoowvicaALAqcfmGrsSD +#undef mZJOXxx7hbtRSTyy_HjGF +#undef mYg2fb_0h62GR73b_cpn9 +#undef mnCvMc73RamSZ8lE5SaXG +#undef mUvejUG0VZ6oaFYLfv96Z +#undef mnxqg8Uow3e4hAyXi7IeZ +#undef mwhGtbRL66FztkRtZ0QI_ +#undef mJSr1xT3rjrluqpa47g9Y +#undef mqed_EcKcpv3tmsK0VwPq +#undef maTpexuiU56_wx8NMsDqq +#undef mud4sr7JVgGG6yDxhsQoI +#undef mXx9mzEZ3WuXitLsCMbS3 +#undef mmwuJQME0484L7jN0wNls +#undef mzuL30IhryR3NJMszS89h +#undef mpQACTL4b3pHMD127IZSN +#undef mZKQBVu9NPSaSKDvETZgYMQILvBIUsb +#undef muzBQurHIfaSICJbRjaWh +#undef mr4zczxVHQA3dSD8whfSj +#undef mI4sf76lr2ENejiQIjqzJ +#undef mI1ri11eHWS0GoQQjfv_u +#undef mJSJkb3ccP0_n2Wxy8nWh +#undef mxjH4eEwkhiNcmUP6GEXq +#undef mM1pbAJE40pyDAsPbwwMd +#undef mfQdV5_coeVOh0_XAr72d +#undef mN6OdwmNUVjXUhxmeGf8J +#undef moj9aYgB8JD1AgO4ICT3d +#undef mTIqUWMZAhhidB3B7gCmt +#undef mW37fLe5jzVXLk4yUjj24 +#undef migdvOq5L79sWQtwLyhs2 +#undef meKZnYzO2FX6PDdko0XJI +#undef m_18997e8JQQFco5N9dHK +#undef mdYtz2htQZh8P7qHU8sOccXiq0Jsbpd +#undef mUAT7RqwcWJKHzYQUCA0y +#undef mypwvI9nBVxZQoSRivBsz +#undef myMbdRujQRRGxZa_esh6OHxPU22Olyw +#undef m_2Wdq9qctokcWGW9B7eI +#undef mj0SmRpcdB2TRl5kdNdBQnXpbI2PaTI +#undef mZWm2nGx_Hxwoni8yg8Qj +#undef mAw0cMDkuY7VauTjR_gzc +#undef mXNcG_XejCUhS0WdQbrzCqFiifRHEiN +#undef mzjX0iRvCYGhZO2ITjcdt +#undef m_5q1OVTkJJKfB_ISHjog +#undef mCw9yl5OPmGbIXjCTLMgT +#undef mnfv75cfRX5nwn_P3W2SZ +#undef mkvvczg0if8KqjNRfebjz +#undef mhSjwWsm2mahiTUSTjt6nFB03As_xU3 +#undef mOMfyQeUFCcsFk8Ad4BBL +#undef mNUuCaMUS8zqfbXCimtgj +#undef mnPfMWb2f1m2VXrwtLuBn +#undef mL3fOciX21BVRqsrLjDqQ +#undef mzrwOkaVNQ12qikoacOtS +#undef m_WYn2n0wuk6UJ5kGIQak +#undef mLPHimc4fzfm6eoFIZbqS +#undef mIkusqIJdd_o34vSBgzWv +#undef mJYXLtUQ27au4beQhf0PM +#undef mgg_rkv_YJplcQCUd_HA7fw3Qmhkmhw +#undef mVM77PvnlvRK1mLTKRKei +#undef mi4UDYlJVme2p8vz8XCwn +#undef mQDl1AFw1LpP3Fl6VsKxWq1Cu_KGgPR +#undef mlNC5dwEflF9t_I2G7kwV +#undef mdV71Y1rT0MkSZQco4pkM +#undef mGXDvm2ZdrqugaoZ1YccvqzabYqkG2k +#undef mJKRIv5t9rcExx2BgWlkY +#undef mR9ASd2W_8LE4mOR7w3js +#undef mK4rObJyYX6HJZfVJKntT +#undef msAueAn4jz6msdaMAOFvD +#undef mBEcaTi01GHGicTdCFjoM +#undef md2kXkeBxboEMBU2AV_5s +#undef mKHRSL6QRz79M7iwb3xFq +#undef mTUb9WYxxxWOpnX_tuW8L +#undef mm4diUXyy908ilcG8VsiM +#undef mEvpZvX3Pr_xoJcbIft169GSIJ4Uo3B +#undef mfoiPdsHJ12pw0fAmu2LO +#undef mmombSefdt4OQYXhCimSX +#undef mNTqpwjT561WC_1cfoCEr +#undef mpNsMq_Jsh9rRugWA0zzy +#undef mPkRdGYYZOKBHLvkzvyRk +#undef mvvQZKXqZ3gS6vWzM21uf +#undef mkQAXn4tEgxUMacHRt_8uGD2gBZRF5t +#undef meHoDa0aUmPvFXvZMmfuA +#undef mkMSqyZx8knDVKKeQRRAPOPQ1OycFsk +#undef mjSoZeXICFupmRJnwixfY +#undef mARbu_1sRtfpk1suZIE5h +#undef ml7ROdNRafN054xhICX2X +#undef mR3g6IaCAGZgxHIA8qCxW +#undef mIpgSd4v5yWrnWkLSTFr4 +#undef mvVntD47RvCRRdFhEAzH2 +#undef mpdkR8_dmu0PH3OVmq923 +#undef milR3XNnU1JDeN9uyM761 +#undef mxQppl_B1tP4_S2CE3A7S +#undef mnr9KiD3xP6jhiP0klzs8 +#undef mqoG7Riz1FpYN6K49t8kk +#undef mBf0JMOxQ3sCg9N87xsxR +#undef mL9fuPZuqOi9x2FhIqvy1 +#undef mM2m_2Donhjltd0Debl64 +#undef mEyjl8Y5Ko8WIO7rc8xjy +#undef mcVfnknnHgJjobEYbCQZb +#undef mJZTaq8b9U6IHm6Fo0zfj +#undef mVMtoBTx7Atu07C1zpSOZ +#undef mtPeORXsOWhCCSWRotXA_ +#undef mjtgzOH8_fFDjnCUIvpJR +#undef ml8k79uncra_1jDk9y35b +#undef mB9JHSBU95BEjegV45XDO +#undef mHiYGul5svZyW_rLyOjTu +#undef mrFprXhaW2MYwjyrlnlK2 +#undef mgjLIBeE0wg2QrojbWXXE +#undef mFIC1mtAi41jxmBTb3wHn +#undef mT1Yuv8tLPubZaOzlRCjX +#undef mahSq6rrq2neTeBW0KH49DPaFsniYhL +#undef mH81SrGjFrRCXYSiJnoqa +#undef mmFbqqNxE6b68zHtj1L1b +#undef mPQkyiUN1BvHTMgAxqODe +#undef mjlW6Gr9BKXBEqm9b7AyH +#undef mbtyTfpzqoLMszlSfGVhS +#undef mUbpV4lfDef5exLGNpWAnT12YiDu_kX +#undef mP4rxLIewwXLg47glswZS +#undef mBsNR7a9eCj4e2paObbgMzu5XwLAjnm +#undef mIE0w_d0lIS7gkIc0JjTYwBjOAZ85XL +#undef mtWQnh_W_PD5ev5w8AW0s +#undef m_YweHWYbkpdV40mXJspN +#undef motTJdCC_9geof6XxtOIX +#undef mQs7VG4JKWIimbZO9fFo8 +#undef mwC9HboO7mY5my_bYOgOp +#undef mrWabZl6Yqxhh9lJh_vp9 +#undef mk0UDRIyOODBYPpNMMtOc +#undef mzZIX41vw1HHV8g5Zis4L +#undef mgeGMjcucDsavdvBBcXoD75__Tb01sm +#undef mkr0aLVnJz5CaZvioiLL7 +#undef mfJjRpXi94twT9pqD5JVX +#undef mD5j4pDCOs2SM4dLbugLG +#undef mbd03FIo9GTdRlDtujpAU +#undef mf4r5S0Gz5iK0mQBxOgrA +#undef mkYawy3Jp4pgcXnw3fgN3 +#undef mfKuHXwnr7XBA7NCf6pZq +#undef mfZqF0j4sUltUngd4Hj5Y +#undef mwE6oBl5ZQ79F6Ove8epW +#undef maNkjFQf7KL90cn5vbMa3 +#undef msgGhTpJsjlaQFml28rg7 +#undef mdNNjVkqM2InU1bCHGxmP +#undef mBx7lmwJEgh_boAo7hHD4 +#undef mlgPh47K_7EW2ZXBliaid +#undef mzRXDilasYlw5CVJtdYdM +#undef mazMo2N6FXwsNwoWMaXmw +#undef mwgU_GguJtAB5Bb35MdwyMTlNysOLJW +#undef my9HJ8yK6DJjsZPdzWxZL +#undef mywDDUpEYndE3A45RHsoU +#undef mcusq_XAMIIwDvb7lMCrf +#undef mlxwRZWmFsIX03zy3tTy0 +#undef mKi8kBZaMYwKlooGDcleR +#undef mRWp04iJpyRq8tILClaZJ +#undef mzHszbbCS_cUrYyWLxL9J +#undef mKwKqgpBT0nQRvDGpT5CT +#undef mkgqYPwbi1srAPQNDI_PpWZgk3gH9Ct +#undef mEy_pGq0H0Ns418E2TeZz +#undef mSNCcmKF29PRGlI8Tdwja +#undef mWrGjq0Squbg2ySQrv2yy +#undef mhOJP7GTKtZVREYuK8qsM +#undef mTvuqEbq8QyE7GGDRvvUi +#undef mniKBlIuV5usw0rljtOxS +#undef msDUdqGgg_34u9hXbBbP6 +#undef mdA8CkxC2ABNB6wmuvTfw +#undef mS3KOSwoqktmfbJXrTgh30aLzdZFDf5 +#undef mEl0x2A3ElD6IIGxgIMh1 +#undef mZi7qi6srAkaKViRVPr2V +#undef mLS7Y36zZso1BwBUg8wDr +#undef mwmTl_1WKubaBtbkcxNw2 +#undef mO54HUFE7XGVtlHtttmH3 +#undef mMa_6lMFLoFYPgu9fRTI1 +#undef maDHAuramjTITZ8BkVyc3 +#undef mS3cOaukxo2FRb5RvHVc4 +#undef mipMN4mtnGA1X8ocw1VUzyTesbkEBOw +#undef mueL4P4xnm8R1M0bl8Ojg +#undef mMepmESYShQYpe8JyLHO6 +#undef msRO7__IOXu6L3zcMPeT2 +#undef mhgnRFmDEM5LAURVG5y1L +#undef mZZ26QMzJc_5LIwefugPz +#undef mqzzPJxLsV4dnyMti4gfP +#undef mDpKPA1KOuuQehqrHJtsl +#undef mo5687q03mFTCWmTFL22s +#undef mKiDysFpzxUykXXw_WZfH +#undef mWNSsa0FomEI5wNcyNLqT +#undef mnZS4TInrvaTXnZxKixov +#undef mCW_zvfcw3_KvOK_XS8HP +#undef moxT8MWfNzFm3p7C1XLDk +#undef mcX71Wu1NrgiE1PjmF5oW +#undef miiVgeXn417nCjY5ebPhf +#undef mDk1S9vejmO23nQ14m4JM +#undef mW_kHdhknJnJHqJtLDQ1K +#undef mHc4_w2MgUHx4283kOjz9 +#undef mSiHrrzr4Y0scm_4uqOCv +#undef msKAlT0dx6w27y9yHjm3iwlc_YIajMN +#undef mrI60jYuZ1dFPDfd24M0Q +#undef mZ4GZ4UmqxVyfyG8CPz5a +#undef mjn2WKwnpSiVmCWLEjQ5k +#undef mohUEWtGNSJiaUfYS_hHU +#undef mj2vTnvmJGQRTP74fz5th +#undef mfkiYufvbU5mF9mdgM8ig +#undef mxbbdZ8472z3S1r1q5ZWj +#undef mRzFXIQ0M4lxEiykp0tGE +#undef mdY97YGxqZoJZ4psVpCYa +#undef mmRqfJAp91BT5F8NaZMmM +#undef mBbED78xkAlNEldBsfZoY +#undef mtehHpUuknvUTAKK7BNgA +#undef mX2uK3ci5pcPqQSvs4amk +#undef mLq0l_9mYawwF56GLqBiO +#undef mUzQAwxDAK5N1NNCaNFl_ +#undef mnv3HCmWHbNAEwSFeikW_ +#undef mYpuIV2wVprROhZ0gZwqQ +#undef mB9YvSPWz0tX4EZ0kP3Cu +#undef mjE2XFXDR2hHCf8IsA1BO +#undef mDEbKniJvTruRfyANln1hDcaOxjifIj +#undef mtAlnZAB81NJEQfKELvkr +#undef mqefKqLpc5MfNVAgzWWfC +#undef mwUUBDVL49RrRRTgyVPVN +#undef mCEME69o7Es8kNPY_qo8L +#undef mHt2jDj4LBpP36tiW9beq +#undef mcLZRXidREDnQsUILaskKBiM_OAG8ua +#undef mGQgYgclze4X2bB4vpuzW +#undef mbldl9dwMrRmnA2YXgRup +#undef mbubCLceOr5QXaiOQQPP1 +#undef mpqi2n0ljngTDl3zfRcZY +#undef mZ50SiWxR46W1PrEhhcm6_ytqgOjxnH +#undef mXAbaapmUexXuxomQ2UOp3r69lu4JB1 +#undef mknpWNnES4R_63cdbcdXV +#undef mCuRJqKBRH_BrOMv7hXsF +#undef miJ4T9koNX5tdXmZ5uaAF +#undef mrZQSpiPc5lDdrE7lGVdv +#undef mzAWY6BVbyF5XGfs95ZTo +#undef meq9uMtFTWeqAgMuQsOtx +#undef mkVYTFw6Vlh64vnWxeVSN58OvdxO7zz +#undef mJ6HDMRJxEkLjnW10cwL8DIg6XlfbUr +#undef mj5ixplkQLbcxKyYSRwxy +#undef mi6HZqmh8GILM6LjanUt5 +#undef m_Tae7Y9Y2VD1QQBLzq4Y +#undef mIivpa7B9YEutjvbp_HF0 +#undef mOO4AmPyU12o_w01ECkUl +#undef muSdZAgzhs5ln2vx_pg0w +#undef mKv065jc1LeatUiqpqepg +#undef mF7PjcGzXBfuvYPxX4ENs +#undef mYhDj2gAIVF7iiyAIzfLc +#undef mqQ3hcKeFeE4oJoHQSvf1 +#undef mnXWkAlgXzCuQoJEu5uiO +#undef mMj_9sE1weayB75v7BdK8 +#undef mGHOYAWjopscrujOCjpSi +#undef m_xN3cfw5kHiuUQhDuDqe2YDOeutmBG +#undef mR5JEG117hlb3MtJMpeEA +#undef meadcZiQDrRuC0Tmbyyiu +#undef mampM4g9ObUpU_xCDEpgQ +#undef mSpGFgQwHX_r9ijW72OO0 +#undef msWHPNAG9RJ8USwCYjIRg +#undef mD8SrJPNcBYa2ZA8fnZd_4tt9M8h3dL +#undef mlPYm0vEibuOv_LKABukZ +#undef mwoHtFc7XtGdE5RWuAZoG +#undef mJfHf6vHjeGZbDkm_IWNg +#undef mGdAJfTAuDccsggh4RYB5 +#undef mOnkdM0WujiddAefb4ESe +#undef mUp9jH_JJkeWGYg6SPvxb +#undef mdoRwfAhRUkJByfoNRUvb +#undef md4VXnnHqGZYN9FfEwMCW +#undef mpfHVtwBeRCF4HzfR5aYa +#undef mtawfM3ndXCRasZXQxRrp +#undef mzz466vkULaDwnx05qd82 +#undef mj4gNTNt3bmCYzbhzWyqTuvT9P3fS9s +#undef mDTlqiHhmW7Np9mQzo1tz +#undef mfaBCDA_1mB_o1gczVteCCzLS9jytzz +#undef msecMYaXfF46rGGcWJxuScGlv8bYIpo +#undef me_oz2FFDkcB79njugEzc +#undef mo6RNiDqZJd5bPrKTOqBN +#undef mnaeVhufQTwT_lV4TnsPF +#undef mZAlRw_vXw7OrhwXXa1s2 +#undef mmAweGjgflL1M_L8xxbS5 +#undef mj8J6mUMVIiLNPC32AT2p +#undef mfPiMJHfWML2WymRvotni +#undef mvxcxvBinAJ8yONOAxeJ3 +#undef mi0l_sHwUblCkb4iaLokRozuEWNdBw6 +#undef mXPig4KjJlLryx1k7a1qv +#undef mZvFBh86Am0OfcHWSxajt +#undef mKlU2t7ATzFQCzp03OHXo +#undef mBY9q0vKK0__eH5VQs9_L +#undef mrVo1fO7oMN0F0LcGmw_f +#undef mRkPOYbSt70qZdeFG7KTU +#undef mUsuCEIFvRP_D44KPaQY47o4ispy8Vj +#undef mKEA1BZI3NTi8QvqudEdc +#undef maFw6BG67rqfttMYNKgoNemSsvLkQYa +#undef mGQ4ZN1hA5s9kbimw7Qwy +#undef miU1_742S5SYXnR5Jx89T +#undef mjAnZdEfD7dHR86j3d92F +#undef mOf9_wb83eei1ZBzVuOZTTfg41x_5sS +#undef mNRgx_n6AYQCSB5qW3w3m1_KYB5I5yI +#undef my6ztJkSs2s9dWfJOJksF +#undef mVDeIkD6a7uU0LqFHLuPG +#undef mS5WCLZvcR3iydjHqSMii +#undef mS6JTMBdIbEJgKM_vQoSK +#undef m_BrEaPHfim2E9yF6_ZvY +#undef monM9oNPqUFsPMMVWOpTatnkGAmgDe9 +#undef mQ3MpK6vlWIM1vTRpOqFk +#undef mDe6Xdhfu94h0bVchSL24UZegztDHht +#undef mhen8iRk76Q4ezN_ZTavu +#undef mEb0vgWbp62WJkkmtdPujPWI8EMqsYH +#undef mEnhnBFQ3mB4diArixuti +#undef mvvmSM3BA2TJMl_6Z9ScU +#undef md4LgblW399NKaEPBAY3T +#undef mkzazD7jHZVgFFhDw4yAI2XVbfGWV4U +#undef mRHVbf6L_uqgqJB68GawV +#undef msUrKsbZb01INfsQYkuex +#undef mPBz2W83ARDLALxh_6rJK +#undef mDPHjdm2_QWPyhebFvYkD +#undef mc8ipMXPIMdxjmKKG4E6NKlqXdYMncM +#undef myuvjPnvzcBE3NfHkRLiX +#undef mYB0YoRP6itbUawfbPusv +#undef mMvWJbWSLKEHq4F0uh_XL +#undef mnpE_s7DSpkcZ5cnGnc16 +#undef mEqTIrKKpbyOgBfvxq5Uo +#undef mBndUu3vn0UYS7kuL9bT2 +#undef mD_3HKaGheLWoKIFvCH3L +#undef mrtb_bhYbXTw3XOs4vV1F +#undef mHN4QkSpFuhZZROE3e75ST2ernStapx +#undef mobX070S3wO6zxczaIZzQ +#undef mx4CWeitM5Hu_IGDB8OfADm3WvgXcV4 +#undef mjQJF2BhvHcfP6fiRsDi0 +#undef mQsl9uLsiN5rbnaTCC5RvHSqd1LVP7E +#undef mxK3g5IVylkgINFWSbxF8 +#undef mLEPndrD0EDs3kVH87Dc9 +#undef mYV98481WEquqd1AECvpqWYdnflE9jF +#undef mS_3jX9nIMiDQ3_4oIDIrZqK46910cN +#undef m_iMEsCNnjEITB27sIXurIsGPpif5XE +#undef mbSdXRep8t2vTB1sedPyt +#undef mcmEFUHvzwZHvsOYCgnyC +#undef mZfa6hQ3HuMhd3Y2jm07Yo8aDwvsiTR +#undef mO0FjLQgixFPExZXiYeXr8hk69NoWuX +#undef mxRngYN6opotzgq0i2yF0 +#undef ma8foCOgNMskkXnP7fzWdE7PnvWtDfR +#endif diff --git a/src/aruco/fractaldetector.cpp b/src/aruco/fractaldetector.cpp new file mode 100644 index 0000000..aa1371b --- /dev/null +++ b/src/aruco/fractaldetector.cpp @@ -0,0 +1,145 @@ +#include "fractaldetector.h" +#include "opencv2/calib3d/calib3d.hpp" +#include +#include "cvdrawingutils.h" +#include +#include "aruco_cvversioning.h" + +namespace aruco +{ + FractalDetector::FractalDetector() + { + _markerDetector = new MarkerDetector(); + }; + + void FractalDetector::setConfiguration(int params) + { + _fractalLabeler = FractalMarkerLabeler::create((FractalMarkerSet::CONF_TYPES)params); + _params.configuration_type=FractalMarkerSet::getTypeString((FractalMarkerSet::CONF_TYPES)params); + _markerDetector->setMarkerLabeler(_fractalLabeler); + } + + void FractalDetector::setConfiguration(std::string params) + { + _params.configuration_type=params; + _fractalLabeler = FractalMarkerLabeler::create(params); + _markerDetector->setMarkerLabeler(_fractalLabeler); + } + + void FractalDetector::drawMarkers(cv::Mat &img) + { + float size= std::max(1.,float(img.cols)/ 1280.); + for(auto m:Markers) + m.draw(img, cv::Scalar(0, 0, 255), size, false); + } + + void FractalDetector::draw2d(cv::Mat &img){ + if(Markers.size() > 0) + { + std::map id_fmarker = _fractalLabeler->_fractalMarkerSet.fractalMarkerCollection; + + std::vector inners; + std::map> id_innerCorners = _fractalLabeler->_fractalMarkerSet.getInnerCorners(); + for(auto id_innerC:id_innerCorners) + { + std::vector inner3d; + for(auto pt:id_innerC.second) + inners.push_back(cv::Point2f(pt.x,pt.y)); + } + + std::vector srcPnts; + std::vector point2d; + for(auto m:Markers) + { + for(auto p:id_fmarker[m.id].points) + { + cv::Point3f p3d = p/(_fractalLabeler->_fractalMarkerSet.getFractalSize()/2); + srcPnts.push_back(cv::Point2f(p3d.x, p3d.y)); + } + for(auto p:m) + point2d.push_back(p); + + } + + cv::Mat H; + H = cv::findHomography(srcPnts, point2d); + std::vector dstPnt; + cv::perspectiveTransform(inners, dstPnt, H); + + float size= std::max(1.,float(img.cols)/ 1280.); + for(auto p:dstPnt) + cv::circle(img, p, size, cv::Scalar(0,0,255), CV_FILLED); + } + } + + void FractalDetector::draw3d(cv::Mat &img, bool cube, bool axis){ + if(Tracker.isPoseValid()) + { + std::vector innerPoints3d = Tracker.getInner3d(); + std::vector innerPoints; + projectPoints(innerPoints3d, Tracker.getRvec(), Tracker.getTvec(), _cam_params.CameraMatrix, _cam_params.Distorsion, innerPoints); + for(auto p:innerPoints) + circle(img, p, 3 , cv::Scalar(0,0,255),CV_FILLED); + + //Draw cube + if(cube) + { + std::map id_fmarker = _fractalLabeler->_fractalMarkerSet.fractalMarkerCollection; + for(auto m:Markers) + draw3dCube(img, id_fmarker[m.id], _cam_params, 2); + } + + //Draw axes + if(axis) + CvDrawingUtils::draw3dAxis(img, _cam_params, getRvec(), getTvec(), 1); + } + } + + void FractalDetector::draw3dCube(cv::Mat& Image, FractalMarker m, const CameraParameters& CP, int lineSize) + { + cv::Mat objectPoints(8, 3, CV_32FC1); + + float halfSize = (m.getMarkerSize()/_fractalLabeler->_fractalMarkerSet.getFractalSize()); + float msize= (m.getMarkerSize()/_fractalLabeler->_fractalMarkerSet.getFractalSize())*2; + + objectPoints.at(0, 0) = -halfSize; + objectPoints.at(0, 1) = -halfSize; + objectPoints.at(0, 2) = 0; + objectPoints.at(1, 0) = halfSize; + objectPoints.at(1, 1) = -halfSize; + objectPoints.at(1, 2) = 0; + objectPoints.at(2, 0) = halfSize; + objectPoints.at(2, 1) = halfSize; + objectPoints.at(2, 2) = 0; + objectPoints.at(3, 0) = -halfSize; + objectPoints.at(3, 1) = halfSize; + objectPoints.at(3, 2) = 0; + + objectPoints.at(4, 0) = -halfSize; + objectPoints.at(4, 1) = -halfSize; + objectPoints.at(4, 2) = msize; + objectPoints.at(5, 0) = halfSize; + objectPoints.at(5, 1) = -halfSize; + objectPoints.at(5, 2) = msize; + objectPoints.at(6, 0) = halfSize; + objectPoints.at(6, 1) = halfSize; + objectPoints.at(6, 2) = msize; + objectPoints.at(7, 0) = -halfSize; + objectPoints.at(7, 1) = halfSize; + objectPoints.at(7, 2) = msize; + + + std::vector imagePoints; + projectPoints(objectPoints, getRvec(), getTvec(), CP.CameraMatrix, CP.Distorsion, imagePoints); + + for (int i = 0; i < 4; i++) + cv::line(Image, imagePoints[i], imagePoints[(i + 1) % 4], cv::Scalar(0, 0, 255, 255), lineSize); + + for (int i = 0; i < 4; i++) + cv::line(Image, imagePoints[i + 4], imagePoints[4 + (i + 1) % 4], cv::Scalar(0, 0, 255, 255), lineSize); + + for (int i = 0; i < 4; i++) + cv::line(Image, imagePoints[i], imagePoints[i + 4], cv::Scalar(0, 0, 255, 255), lineSize); + } +}; + diff --git a/src/aruco/fractaldetector.h b/src/aruco/fractaldetector.h new file mode 100644 index 0000000..dcd8112 --- /dev/null +++ b/src/aruco/fractaldetector.h @@ -0,0 +1,115 @@ +#ifndef _ARUCO_FractalDetector_H +#define _ARUCO_FractalDetector_H + +#include "markerdetector.h" +#include "fractallabelers/fractallabeler.h" +#include "aruco_export.h" +namespace aruco { + class ARUCO_EXPORT FractalDetector + { + struct ARUCO_EXPORT Params + { + std::string configuration_type; + }; + + public: + FractalDetector(); + + /** + * @brief setConfiguration + * @param configuration fractal id + */ + void setConfiguration(int configuration); + + /** + * @brief setConfiguration + * @param configuration fractal file + */ + void setConfiguration(std::string configuration); + + /** + * @brief setParams + * @param cam_params camera parameters + * @param markerSize in meters + */ + void setParams(const CameraParameters& cam_params, float markerSize) + { + _cam_params = cam_params; + _msize = markerSize; + + Tracker.setParams(cam_params, getConfiguration()); + } + + // return fractalmarkerset + FractalMarkerSet getConfiguration() + { + return _fractalLabeler->_fractalMarkerSet; + } + + // return true if any marker is detected, false otherwise + bool detect(const cv::Mat& input) + { + Markers = _markerDetector->detect(input); + + if(Markers.size() > 0) return true; + else return false; + } + + // return true if the pose is estimated, false otherwise + bool poseEstimation() + { + if (_cam_params.isValid()) + { + return Tracker.fractalInnerPose(_markerDetector, Markers); + } + else + return false; + } + + // return the rotation vector. Returns an empty matrix if last call to estimatePose returned false + cv::Mat getRvec(){ + return Tracker.getRvec(); + } + // return the translation vector. Returns an empty matrix if last call to estimatePose returned false + cv::Mat getTvec(){ + return Tracker.getTvec(); + } + + //void drawImage(cv::Mat &img,cv::Mat &img2); + + // draw borders of markers + void drawMarkers(cv::Mat &img); + + // draw inner corners of markers + void draw2d(cv::Mat &img); + + // draw pose estimation axes + void draw3d(cv::Mat &img, bool cube=true, bool axis=true); + + // draw marker as cube + void draw3dCube(cv::Mat& Image, FractalMarker m, const CameraParameters& CP, int lineSize); + + // return detected markers + std::vector getMarkers() + { + return Markers; + } + + private: + // return image pyramid + std::vector getImagePyramid() + { + return _markerDetector->getImagePyramid(); + } + + std::vector Markers; //detected markers + FractalPoseTracker Tracker; + cv::Mat _rvec,_tvec;//CV32F + Params _params; + float _msize; //marker size + CameraParameters _cam_params; //Camera parameters + cv::Ptr _fractalLabeler; + cv::Ptr _markerDetector; + }; +} +#endif diff --git a/src/aruco/fractallabelers/fractallabeler.cpp b/src/aruco/fractallabelers/fractallabeler.cpp new file mode 100644 index 0000000..8569182 --- /dev/null +++ b/src/aruco/fractallabelers/fractallabeler.cpp @@ -0,0 +1,152 @@ +#include "fractallabeler.h" + +#include +#include "../aruco_cvversioning.h" +namespace aruco +{ + + void FractalMarkerLabeler::setConfiguration(const FractalMarkerSet& fractMarkerSet) { + _fractalMarkerSet = fractMarkerSet; + } + + bool FractalMarkerLabeler::detect(const cv::Mat& in, int& marker_id, int& nRotations, std::string &additionalInfo) + { + assert(in.rows == in.cols); + cv::Mat grey; + if (in.type() == CV_8UC1) + grey = in; + else + cv::cvtColor(in, grey, CV_BGR2GRAY); + // threshold image + cv::threshold(grey, grey, 125, 255, cv::THRESH_BINARY | cv::THRESH_OTSU); + + std::map > nbits_innerCodes; + + for(auto bitsids:_fractalMarkerSet.nbits_fractalMarkerIDs){ + + int nbits = bitsids.first; + std::vector innerCodes; + getInnerCode(grey, nbits, innerCodes); + + if (innerCodes.size()>0){ + if (sum(innerCodes[0])[0]!=0){ + nbits_innerCodes[nbits]=innerCodes; + } + } + } + + if ( nbits_innerCodes.size()==0)return false; + + //check if any dictionary recognizes it + for(auto bit_innerCodes:nbits_innerCodes){ + + uint32_t nb = bit_innerCodes.first; + auto innerCodes = bit_innerCodes.second; + + for (int i = 0; i < 4; i++) + { + if (_fractalMarkerSet.isFractalMarker(innerCodes[i], nb, marker_id)) + { + // is in the set? + nRotations = i; // how many rotations are and its id + return true; // bye bye + } + } + } + return false; + } + + + std::string FractalMarkerLabeler::getName() const + { + return "fractal";; + } + + bool FractalMarkerLabeler::getInnerCode(const cv::Mat& thres_img, int total_nbits, std::vector& innerCodes) + { + int bits_noborder = static_cast(std::sqrt(total_nbits)); + int bits_withborder = bits_noborder + 2; + // Markers are divided in (bits_a+2)x(bits_a+2) regions, of which the inner bits_axbits_a belongs to marker + // info + // the external border shoould be entirely black + cv::Mat nonZeros(bits_withborder,bits_withborder,CV_32SC1); + cv::Mat nValues(bits_withborder,bits_withborder,CV_32SC1); + nonZeros.setTo(cv::Scalar::all(0)); + nValues.setTo(cv::Scalar::all(0)); + for (int y = 0; y < thres_img.rows; y++) + { + const uchar *ptr=thres_img.ptr(y); + int my= float(bits_withborder)*float(y)/ float(thres_img.rows); + for (int x = 0; x < thres_img.cols; x++) + { + int mx= float(bits_withborder)*float(x)/ float(thres_img.cols); + if( ptr[x]>125) + nonZeros.at(my,mx)++; + nValues.at(my,mx)++; + } + } + cv::Mat binaryCode(bits_withborder,bits_withborder,CV_8UC1); + //now, make the theshold + for(int y=0;y(y,x)>nValues.at(y,x)/2) + binaryCode.at(y,x)=1; + else + binaryCode.at(y,x)=0; + } + + //check if border is completely black + for (int y = 0; y < bits_withborder; y++) + { + int inc = bits_withborder - 1; + if (y == 0 || y == bits_withborder - 1) + inc = 1; // for first and last row, check the whole border + for (int x = 0; x < bits_withborder; x += inc) + if (binaryCode.at(y,x)!=0 ) return false; + } + + //take the inner code + + cv::Mat _bits(bits_noborder,bits_noborder,CV_8UC1); + for(int y=0;y(y,x)=binaryCode.at(y+1,x+1); + + // now, get the 64bits ids + int nr = 0; + do + { + innerCodes.push_back(_bits); + _bits = rotate(_bits); + nr++; + } while (nr < 4); + return true; + } + + // convert matrix of (0,1)s in a 64 bit value + uint64_t FractalMarkerLabeler::touulong(const cv::Mat& code) + { + std::bitset<64> bits; + int bidx = 0; + for (int y = code.rows - 1; y >= 0; y--) + for (int x = code.cols - 1; x >= 0; x--) + bits[bidx++] = code.at(y, x); + + return bits.to_ullong(); + } + + cv::Mat FractalMarkerLabeler::rotate(const cv::Mat& in) + { + cv::Mat out; + in.copyTo(out); + for (int i = 0; i < in.rows; i++) + { + for (int j = 0; j < in.cols; j++) + { + out.at(i, j) = in.at(in.cols - j - 1, i); + } + } + return out; + } +} + diff --git a/src/aruco/fractallabelers/fractallabeler.h b/src/aruco/fractallabelers/fractallabeler.h new file mode 100644 index 0000000..c428c91 --- /dev/null +++ b/src/aruco/fractallabelers/fractallabeler.h @@ -0,0 +1,56 @@ +#ifndef _ARUCO_FractalLabeler_H +#define _ARUCO_FractalLabeler_H + +#include "../markerlabeler.h" +#include "fractalposetracker.h" + +namespace aruco +{ + class FractalMarkerLabeler : public MarkerLabeler + { + public: + static cv::Ptr create(std::string params) + { + FractalMarkerSet fractalMarkerSet = FractalMarkerSet::load(params); + FractalMarkerLabeler* fml=new FractalMarkerLabeler(); + fml->setConfiguration(fractalMarkerSet); + return fml; + } + + static cv::Ptr create(FractalMarkerSet::CONF_TYPES conf) + { + FractalMarkerSet fractalMarkerSet = FractalMarkerSet::loadPredefined(conf); + FractalMarkerLabeler* fml=new FractalMarkerLabeler(); + fml->setConfiguration(fractalMarkerSet); + return fml; + } + + void setConfiguration(const FractalMarkerSet& fractMarkerSet); + + //static bool isFractalDictionaryFile(const std::string &path); + + virtual ~FractalMarkerLabeler() + { + } + + //bool load(const std::string &path); + + // returns the configuration name + std::string getName() const; + + // main virtual class to o detection + bool detect(const cv::Mat& in, int& marker_id, int& nRotations,std::string &additionalInfo); + + int getNSubdivisions()const{return (sqrt(_fractalMarkerSet.nBits())+2);} + + FractalMarkerSet _fractalMarkerSet; + + private: + bool getInnerCode(const cv::Mat& thres_img, int total_nbits, std::vector& ids); + cv::Mat rotate(const cv::Mat& in); + uint64_t touulong(const cv::Mat& code); + void toMat(uint64_t code, int nbits_sq, cv::Mat& out); + }; +} + +#endif diff --git a/src/aruco/fractallabelers/fractalmarker.cpp b/src/aruco/fractallabelers/fractalmarker.cpp new file mode 100644 index 0000000..e847a87 --- /dev/null +++ b/src/aruco/fractallabelers/fractalmarker.cpp @@ -0,0 +1,72 @@ +#include "fractalmarker.h" + +#include + + +namespace aruco +{ + FractalMarker::FractalMarker() + { + + } + + FractalMarker::FractalMarker(int id, cv::Mat m, std::vector corners, std::vector id_submarkers) + { + this->id = id; + this->_M = m; + for(auto p:corners) + push_back(p); + + _submarkers = id_submarkers; + _mask = cv::Mat::ones(m.size(), CV_8UC1); + } + + void FractalMarker::addSubFractalMarker(FractalMarker submarker) + { + float bitSize = (at(1).x - at(0).x) / int(mat().cols+2); + float nsubBits = (submarker.at(1).x - submarker.at(0).x) / bitSize; + + int x_min = int(round(submarker[0].x / bitSize + mat().cols/2)); + int x_max = x_min + nsubBits; + int y_min = int(round(-submarker[0].y / bitSize + mat().cols/2)); + int y_max = y_min + nsubBits; + + for(int y=y_min; y(y,x)=0; + } + } + } + + std::vector FractalMarker::getInnerCorners() + { + int nBitsSquared = int(sqrt(mat().total())); + float bitSize = getMarkerSize() / (nBitsSquared+2); + + //Add border bits + cv::Mat markerBorder; + copyMakeBorder(mat(), markerBorder, 1,1,1,1,cv::BORDER_CONSTANT,0); + + std::vector innerCorners; + for(int y=0; y< markerBorder.rows-1; y++) + { + for(int x=0; x< markerBorder.cols-1; x++) + { + + if( ((markerBorder.at(y, x) == markerBorder.at(y+1, x+1)) && + (markerBorder.at(y, x) != markerBorder.at(y, x+1) || + markerBorder.at(y, x) != markerBorder.at(y+1, x))) + + || + + ((markerBorder.at(y, x+1) == markerBorder.at(y+1, x)) && + (markerBorder.at(y, x+1) != markerBorder.at(y, x) || + markerBorder.at(y, x+1) != markerBorder.at(y+1, x+1))) + ) + innerCorners.push_back(cv::Point3f(x-nBitsSquared/2.f, -(y-nBitsSquared/2.f), 0) * bitSize); + } + } + return innerCorners; + } +} + diff --git a/src/aruco/fractallabelers/fractalmarker.h b/src/aruco/fractallabelers/fractalmarker.h new file mode 100644 index 0000000..028fcde --- /dev/null +++ b/src/aruco/fractallabelers/fractalmarker.h @@ -0,0 +1,54 @@ +#ifndef _ARUCO_FractalMarker_H +#define _ARUCO_FractalMarker_H + +#include +#include +#include +#include "../markermap.h" + +namespace aruco +{ + class FractalMarker : public aruco::Marker3DInfo + { + public: + FractalMarker(); + FractalMarker(int id, cv::Mat m, std::vector corners, std::vector id_submarkers); + + //Add new submarker + void addSubFractalMarker(FractalMarker submarker); + + //Get inner corners + std::vector getInnerCorners(); + + //Marker MAT + const cv::Mat mat() const + { + return _M; + } + + //Marker mask (mask applied to submarkers) + const cv::Mat mask() const + { + return _mask; + } + + //Total number of bits + int nBits() + { + return _M.total(); + } + + //Submarkers ids + std::vector subMarkers() + { + return _submarkers; + } + + private: + cv::Mat _M; + cv::Mat _mask; + std::vector _submarkers; //id subfractalmarkers + }; +} + +#endif // FRACTALMARKER_H diff --git a/src/aruco/fractallabelers/fractalmarkerset.cpp b/src/aruco/fractallabelers/fractalmarkerset.cpp new file mode 100644 index 0000000..df41985 --- /dev/null +++ b/src/aruco/fractallabelers/fractalmarkerset.cpp @@ -0,0 +1,828 @@ +#include "fractalmarkerset.h" +#include +#include + +namespace aruco +{ + +FractalMarkerSet FractalMarkerSet::load(std::string info){ + if (isPredefinedConfigurationString(info)) + return loadPredefined(info); + else return readFromFile(info); +} + +FractalMarkerSet FractalMarkerSet::loadPredefined(std::string type){ + return loadPredefined(getTypeFromString(type)); +} + +FractalMarkerSet FractalMarkerSet::loadPredefined(CONF_TYPES type){ + FractalMarkerSet fms; + + switch(type){ + case FRACTAL_2L_6:{ + unsigned char _conf_2L_6[] = { + 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, + 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0xbe, 0xab, 0xaa, 0xaa, 0x3e, + 0x00, 0x00, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0x3e, 0xab, 0xaa, 0xaa, 0x3e, + 0x00, 0x00, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0x3e, 0xab, 0xaa, 0xaa, 0xbe, + 0x00, 0x00, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0xbe, 0xab, 0xaa, 0xaa, 0xbe, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 + }; + unsigned int _conf_2L_6_len = 272; + + std::stringstream stream; + stream.write((char*) _conf_2L_6, sizeof(unsigned char)*_conf_2L_6_len); + _fromStream(fms, stream); + }break; + case FRACTAL_3L_6:{ + unsigned char _conf_3L_6[] = { + 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, + 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, + 0xb7, 0x6d, 0xdb, 0xbe, 0xb7, 0x6d, 0xdb, 0x3e, 0x00, 0x00, 0x00, 0x00, + 0xb7, 0x6d, 0xdb, 0x3e, 0xb7, 0x6d, 0xdb, 0x3e, 0x00, 0x00, 0x00, 0x00, + 0xb7, 0x6d, 0xdb, 0x3e, 0xb7, 0x6d, 0xdb, 0xbe, 0x00, 0x00, 0x00, 0x00, + 0xb7, 0x6d, 0xdb, 0xbe, 0xb7, 0x6d, 0xdb, 0xbe, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x25, 0x49, 0x12, 0xbe, + 0x25, 0x49, 0x12, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x25, 0x49, 0x12, 0x3e, + 0x25, 0x49, 0x12, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x25, 0x49, 0x12, 0x3e, + 0x25, 0x49, 0x12, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x25, 0x49, 0x12, 0xbe, + 0x25, 0x49, 0x12, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + unsigned int _conf_3L_6_len = 480; + + std::stringstream stream; + stream.write((char*) _conf_3L_6, sizeof(unsigned char)*_conf_3L_6_len); + _fromStream(fms, stream); + }break; + case FRACTAL_4L_6:{ + unsigned char _conf_4L_6[] = { + 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, + 0x00, 0xef, 0xee, 0xee, 0xbe, 0xef, 0xee, 0xee, 0x3e, 0x00, 0x00, 0x00, + 0x00, 0xef, 0xee, 0xee, 0x3e, 0xef, 0xee, 0xee, 0x3e, 0x00, 0x00, 0x00, + 0x00, 0xef, 0xee, 0xee, 0x3e, 0xef, 0xee, 0xee, 0xbe, 0x00, 0x00, 0x00, + 0x00, 0xef, 0xee, 0xee, 0xbe, 0xef, 0xee, 0xee, 0xbe, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, + 0x00, 0x64, 0x00, 0x00, 0x00, 0xcd, 0xcc, 0x4c, 0xbe, 0xcd, 0xcc, 0x4c, + 0x3e, 0x00, 0x00, 0x00, 0x00, 0xcd, 0xcc, 0x4c, 0x3e, 0xcd, 0xcc, 0x4c, + 0x3e, 0x00, 0x00, 0x00, 0x00, 0xcd, 0xcc, 0x4c, 0x3e, 0xcd, 0xcc, 0x4c, + 0xbe, 0x00, 0x00, 0x00, 0x00, 0xcd, 0xcc, 0x4c, 0xbe, 0xcd, 0xcc, 0x4c, + 0xbe, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, + 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, + 0x00, 0x89, 0x88, 0x88, 0xbd, 0x89, 0x88, 0x88, 0x3d, 0x00, 0x00, 0x00, + 0x00, 0x89, 0x88, 0x88, 0x3d, 0x89, 0x88, 0x88, 0x3d, 0x00, 0x00, 0x00, + 0x00, 0x89, 0x88, 0x88, 0x3d, 0x89, 0x88, 0x88, 0xbd, 0x00, 0x00, 0x00, + 0x00, 0x89, 0x88, 0x88, 0xbd, 0x89, 0x88, 0x88, 0xbd, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00 + }; + unsigned int _conf_4L_6_len = 713; + + std::stringstream stream; + stream.write((char*) _conf_4L_6, sizeof(unsigned char)*_conf_4L_6_len); + _fromStream(fms, stream); + }break; + case FRACTAL_5L_6:{ + unsigned char _conf_5L_6[] = { + 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, + 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, + 0x00, 0x4f, 0xec, 0xc4, 0xbe, 0x4f, 0xec, 0xc4, 0x3e, 0x00, 0x00, 0x00, + 0x00, 0x4f, 0xec, 0xc4, 0x3e, 0x4f, 0xec, 0xc4, 0x3e, 0x00, 0x00, 0x00, + 0x00, 0x4f, 0xec, 0xc4, 0x3e, 0x4f, 0xec, 0xc4, 0xbe, 0x00, 0x00, 0x00, + 0x00, 0x4f, 0xec, 0xc4, 0xbe, 0x4f, 0xec, 0xc4, 0xbe, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, + 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, + 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x7d, 0xcb, 0x37, 0xbe, 0x7d, 0xcb, + 0x37, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x7d, 0xcb, 0x37, 0x3e, 0x7d, 0xcb, + 0x37, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x7d, 0xcb, 0x37, 0x3e, 0x7d, 0xcb, + 0x37, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x7d, 0xcb, 0x37, 0xbe, 0x7d, 0xcb, + 0x37, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, + 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xd9, 0x89, + 0x9d, 0xbd, 0xd9, 0x89, 0x9d, 0x3d, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x89, + 0x9d, 0x3d, 0xd9, 0x89, 0x9d, 0x3d, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x89, + 0x9d, 0x3d, 0xd9, 0x89, 0x9d, 0xbd, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x89, + 0x9d, 0xbd, 0xd9, 0x89, 0x9d, 0xbd, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x21, 0x0d, 0xd2, 0xbc, 0x21, 0x0d, + 0xd2, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x21, 0x0d, 0xd2, 0x3c, 0x21, 0x0d, + 0xd2, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x21, 0x0d, 0xd2, 0x3c, 0x21, 0x0d, + 0xd2, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x21, 0x0d, 0xd2, 0xbc, 0x21, 0x0d, + 0xd2, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, + 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + unsigned int _conf_5L_6_len = 898; + + std::stringstream stream; + stream.write((char*) _conf_5L_6, sizeof(unsigned char)*_conf_5L_6_len); + _fromStream(fms, stream); + }break; + case CUSTOM: + throw cv::Exception(-1,"CUSTOM type is only set by loading from file","FractalMarkerSet::loadPredefined","fractalmarkerset.h",-1); + break; + + default: throw cv::Exception(9001, "Invalid Dictionary type requested", "Dictionary::loadPredefined", __FILE__, __LINE__); + + } + return fms; +} + +bool FractalMarkerSet::isPredefinedConfigurationString(std::string str) { + return getTypeFromString(str)!=CUSTOM; +} + +std::string FractalMarkerSet::getTypeString(CONF_TYPES t) { + switch(t){ + case FRACTAL_2L_6:return "FRACTAL_2L_6"; + case FRACTAL_3L_6:return "FRACTAL_3L_6"; + case FRACTAL_4L_6:return "FRACTAL_4L_6"; + case FRACTAL_5L_6:return "FRACTAL_5L_6"; + case CUSTOM:return "CUSTOM"; + }; + return "Non valid CONF_TYPE"; + } + +FractalMarkerSet::CONF_TYPES FractalMarkerSet::getTypeFromString(std::string str) { + if (str=="FRACTAL_2L_6") return FRACTAL_2L_6; + if (str=="FRACTAL_3L_6") return FRACTAL_3L_6; + if (str=="FRACTAL_4L_6") return FRACTAL_4L_6; + if (str=="FRACTAL_5L_6") return FRACTAL_5L_6; + else return CUSTOM; + } + +std::vector FractalMarkerSet::getConfigurations() { + return {"FRACTAL_2L_6","FRACTAL_3L_6","FRACTAL_4L_6","FRACTAL_5L_6"}; +} + +void FractalMarkerSet::_toStream(FractalMarkerSet &configuration, std::ostream &str) +{ + str.write((char*)&configuration.mInfoType,sizeof(mInfoType)); + str.write((char*)&configuration._nmarkers,sizeof(_nmarkers)); + str.write((char*)&configuration._idExternal,sizeof(_idExternal)); + + for(auto fractal:configuration.fractalMarkerCollection) + { + //ID + int id = fractal.first; + str.write((char*)&id,sizeof(id)); + //NBITS + int nbits = fractal.second.nBits(); + str.write((char*)&nbits,sizeof(nbits)); + //CORNERS + std::vector corners = fractal.second.points; + str.write((char*)&corners[0],sizeof(cv::Point3f)*4); + //MAT + cv::Mat mat = fractal.second.mat(); + str.write((char*)mat.data, mat.elemSize() * mat.total()); + //SUBMARKERS + std::vector sub = fractal.second.subMarkers(); + int nsub = sub.size(); + str.write((char*)&nsub,sizeof(nsub)); + str.write((char*)&sub[0],sizeof(int)*nsub); + } +} + +void FractalMarkerSet::_fromStream(FractalMarkerSet &configuration, std::istream &str) +{ + str.read((char*)&configuration.mInfoType,sizeof(mInfoType)); + str.read((char*)&configuration._nmarkers,sizeof(_nmarkers)); + str.read((char*)&configuration._idExternal,sizeof(_idExternal)); + + for(int i=0; i corners(4); + str.read((char*)&corners[0],sizeof(cv::Point3f)*4); + //MAT + cv::Mat mat; + mat.create(sqrt(nbits), sqrt(nbits), CV_8UC1); + str.read((char*)mat.data, mat.elemSize() * mat.total()); + //SUBMARKERS + int nsub; + str.read((char*)&nsub,sizeof(nsub)); + std::vector id_submarkers(nsub); + if (nsub > 0) + str.read((char*)&id_submarkers[0],sizeof(int)*nsub); + + FractalMarker fractalMarker = FractalMarker(id, mat, corners, id_submarkers); + configuration.nbits_fractalMarkerIDs[mat.total()].push_back(fractalMarker.id); + configuration.fractalMarkerCollection[fractalMarker.id] = fractalMarker; + } + + //Add subfractals + for(auto &id_marker:configuration.fractalMarkerCollection) + { + FractalMarker &marker = id_marker.second; + for(auto id:id_marker.second.subMarkers()) + marker.addSubFractalMarker(configuration.fractalMarkerCollection[id]); + } +} + +void FractalMarkerSet::create(std::vector> regionsConfig, float pixSize) +{ + if(pixSize == -1) + { + mInfoType = NORM; + pixSize = 1; + } + else + mInfoType = PIX; + + _nmarkers = regionsConfig.size(); + _idExternal = 0; + + std::vector submarkers; + submarkers.clear(); + float pix = 0; + for(int n=regionsConfig.size()-1; n>=0; n--) + { + int nVal = regionsConfig[n].first; + int kVal = regionsConfig[n].second; + + cv::Mat mat = configureMat(nVal, kVal); + + pix = (nVal + 2) * pixSize; + std::vector corners = { cv::Point3f(-pix/2, pix/2, 0.), + cv::Point3f(pix/2, pix/2, 0.), + cv::Point3f(pix/2, -pix/2, 0.), + cv::Point3f(-pix/2, -pix/2, 0.) + }; + + FractalMarker fractal = FractalMarker(n, mat, corners, submarkers); + fractalMarkerCollection[n] = fractal; + submarkers.clear(); + submarkers.push_back(n); + + + float kValSup = regionsConfig[n-1].second - 2; + float newP = (nVal+2)/(kValSup); + pixSize = newP * pixSize; + } + + //Normalize corners. Fractal marker: (-1,1,0)(1,1,0)(1,-1,0)(-1,-1,0) + if(isNormalize()){ + for(auto &m:fractalMarkerCollection){ + for(auto &c:m.second.points) + { + c.x/=pix/2; + c.y/=pix/2; + } + } + } +} + +cv::Mat FractalMarkerSet::configureMat(int nVal, int kVal, int maxIter) +{ + //Pixels to configure (n-k region) + std::vector pixels; + for(int y=0; y= kVal+(nVal-kVal)/2) + || (y <= ((nVal-kVal)/2)-1 || y >= kVal+(nVal-kVal)/2)){ + pixels.push_back(cv::Point2i(x, y)); + } + } + } + + int dst_mkr = 0; + int dst_set=0; + + cv::Mat m; + int markerIters = 0; + do{ + std::vector conf_pixels = pixels; + m = cv::Mat::ones(nVal, nVal, CV_8UC1); + +// struct timespec ts; +// clock_gettime(CLOCK_MONOTONIC, &ts); +// srand((time_t)ts.tv_nsec); + + //Random delete half of pixels + int npix = conf_pixels.size()/2; + for(int i=0; i(p.y,p.x) = 0; + + //Check marker distance to itself + int new_dst_mkr = dstMarker(m); + if(new_dst_mkr > dst_mkr) + { + //Check marker distance to set + int new_dst_set = dstMarkerToFractalDict(m); + if(new_dst_set > dst_set) + { + dst_mkr = new_dst_mkr; + dst_set = new_dst_set; + } + } + } while(markerIters++(y,x)=0; + } + } + + return m; +} + +/* + * Calculate minimum distance between marker 'm' and the 4 rotations of each word in the dictionary + */ +int FractalMarkerSet::dstMarkerToFractalDict(cv::Mat m){ + int HDist = m.cols * m.rows; //distancia maxima + int HDistTemp; + + for(auto marker:fractalMarkerCollection) { + if(marker.second.nBits() == m.total()) + { + HDistTemp = dstMarkerToMarker(marker.second.mat(), m); + + if(HDistTemp == 0) + return 0; + else if(HDistTemp < HDist) + HDist = HDistTemp; + } + } + return HDist; +} + +/* + * Calculate minimum distance between marker1 'm' and the 4 rotations of marker2 'm2' + */ +auto rotate=[](const cv::Mat &m) { + cv::Mat out; + m.copyTo(out); + for (int i = 0; i < m.rows; i++) { + for (int j = 0; j < m.cols; j++) { + out.at< char >(i, j) = m.at< char >(m.cols - j - 1, i); + } + } + return out; +}; + +int FractalMarkerSet::dstMarker(const cv::Mat m) { + + int HDist = m.cols * m.rows;//maximum distance + int HDistTemp; + + cv::Mat rot; + m.copyTo(rot); + + + for(int i=0; i<3; i++) + { + cv::Mat diff; + rot=rotate(rot); + cv::compare(rot, m, diff, cv::CMP_NE); + HDistTemp = cv::countNonZero(diff); + if(HDistTemp < HDist) + HDist = HDistTemp; + } + return HDist; +} + +int FractalMarkerSet::dstMarkerToMarker(const cv::Mat m1, const cv::Mat m2) { + + int HDist = m2.cols * m2.rows;//maximum distance + int HDistTemp; + + for(int i=0; i<4; i++) + { + cv::Mat diff; + cv::compare(rotate(m2), m1, diff, cv::CMP_NE); + HDistTemp = cv::countNonZero(diff); + if(HDistTemp < HDist) + HDist = HDistTemp; + } + + return HDist; +} + + +FractalMarkerSet FractalMarkerSet::readFromFile(std::string path) +{ + cv::FileStorage fs; + try + { + fs.open(path, cv::FileStorage::READ); + } + catch (std::exception& ex) + { + throw cv::Exception(81818, "FractalMarkerSet::readFromFile", ex.what() + std::string(" file=)") + path, __FILE__, __LINE__); + } + + FractalMarkerSet configuration; + + fs["mInfoType"] >> configuration.mInfoType; + fs["fractal_levels"] >> configuration._nmarkers; + fs["fractal_external_id"] >> configuration._idExternal; + + cv::FileNode markers = fs["markers"]; + int i = 0; + for (cv::FileNodeIterator it = markers.begin(); it != markers.end(); ++it, i++) + { + int id = (*it)["id"]; + std::vector bits; + + std::vector corners; + std::vector submarkers_id; + + cv::FileNode bitsMarker = (*it)["bits"]; + for (cv::FileNodeIterator itb = bitsMarker.begin(); itb != bitsMarker.end(); ++itb) + { + bits.push_back(*itb); + } + cv::Mat m = cv::Mat(sqrt(bits.size()), sqrt(bits.size()), CV_32SC1); + memcpy(m.data, bits.data(), bits.size()*sizeof(int)); + + m.convertTo(m,CV_8UC1); + + cv::FileNode cornersFractal = (*it)["corners"]; + for (cv::FileNodeIterator itp = cornersFractal.begin(); itp != cornersFractal.end(); ++itp) + { + std::vector coordinates3d; + (*itp) >> coordinates3d; + if (coordinates3d.size() != 3) + throw cv::Exception(81818, "FractalMarkerSet::readFromFile", "invalid file type 3", __FILE__, __LINE__); + cv::Point3f point(coordinates3d[0], coordinates3d[1], coordinates3d[2]); + corners.push_back(point); + } + + cv::FileNode submarkersID = (*it)["submarkers_id"]; + for (cv::FileNodeIterator itm = submarkersID.begin(); itm != submarkersID.end(); ++itm) + { + submarkers_id.push_back((*itm)); + } + + FractalMarker fractalMarker = FractalMarker(id, m, corners, submarkers_id); + configuration.nbits_fractalMarkerIDs[m.total()].push_back(fractalMarker.id); + configuration.fractalMarkerCollection[fractalMarker.id] = fractalMarker; + } + + //Add subfractals + for(auto &id_marker:configuration.fractalMarkerCollection) + { + FractalMarker &marker = id_marker.second; + for(auto id:id_marker.second.subMarkers()) + marker.addSubFractalMarker(configuration.fractalMarkerCollection[id]); + } + + return configuration; +} + + void FractalMarkerSet::saveToFile(cv::FileStorage& fs) + { + fs << "codeid" << "fractalmarkers"; + fs << "mInfoType" << mInfoType; + fs << "fractal_levels" << _nmarkers; + fs << "fractal_external_id" << _idExternal; + fs << "markers" + << "["; + for(auto id_marker:fractalMarkerCollection) { + + FractalMarker marker = id_marker.second; + + fs << "{:" + << "id" << (int)id_marker.first; + + fs << "bits" + << "[:"; + cv::Mat m = marker.mat(); + for (int y = 0; y < m.cols; y++) + for (int x = 0; x < m.rows; x++) + if (m.at(y, x) == 2) + fs << 0; + else + fs << m.at(y, x); + fs << "]"; + + fs << "corners" + << "[:"; + for (auto corner:marker.points) + fs << corner; + fs << "]"; + + fs << "submarkers_id" + << "[:"; + for (auto idsub:marker.subMarkers()) + fs << (int) idsub; + fs << "]"; + + fs << "}"; + } + fs << "]"; + } + + bool FractalMarkerSet::isFractalMarker(cv::Mat &m, int nbits, int& markerid) + { + + bool found = false; + + for(auto id:nbits_fractalMarkerIDs[nbits]){ + FractalMarker fm = fractalMarkerCollection[id]; + + //Apply mask to substract submarkers + cv::Mat m2; + m.copyTo(m2, fm.mask()); + + //Code without submarkers == fractal marker? + if (cv::countNonZero(m2 != fm.mat()) == 0){ + found = true; + + //Change new code!! + ////////////// + markerid = fm.id; + ///////////// + + break; + } + } + + return found; + } + + FractalMarkerSet FractalMarkerSet::convertToMeters(float fractalSizeM) + { + if (!(isExpressedInPixels() || isNormalize())) + throw cv::Exception(-1, "The FractalMarkers are not expressed in pixels", "FractalMarkerSet::convertToMeters", __FILE__, + __LINE__); + + FractalMarkerSet BInfo(*this); + BInfo.mInfoType = FractalMarkerSet::METERS; + + // now, get the size of a pixel, and change scale + float pixSizeM = fractalSizeM / float(BInfo.getFractalSize()); + + for (size_t i=0; i < BInfo.fractalMarkerCollection.size(); i++) + { + //Convert to meters the position fractal marker + for (int c = 0; c < 4; c++) + { + BInfo.fractalMarkerCollection[i][c] *= pixSizeM; + } + } + return BInfo; + } + + FractalMarkerSet FractalMarkerSet::normalize() + { + if (!(isExpressedInPixels() || isExpressedInMeters())) + throw cv::Exception(-1, "The FractalMarkers are not expressed in pixels or meters", "FractalMarkerSet::convertToMeters", __FILE__, + __LINE__); + + FractalMarkerSet BInfo(*this); + BInfo.mInfoType = FractalMarkerSet::NORM; + + float currentHalfSize = BInfo.getFractalSize()/2.f; + + for (size_t i=0; i < BInfo.fractalMarkerCollection.size(); i++) + { + //Normalize the position fractal marker + for (size_t c = 0; c < 4; c++) + { + BInfo.fractalMarkerCollection[i][c] /= currentHalfSize; + } + } + + return BInfo; + } + + std::map> FractalMarkerSet::getInnerCorners() + { + std::map> id_innerCorners; + + for(auto id_fm:fractalMarkerCollection) + { + int id = id_fm.first; + FractalMarker fm = id_fm.second; + + for(auto ic:fm.getInnerCorners()) + id_innerCorners[id].push_back(ic); //Conversion + + } + return id_innerCorners; + } + + cv::Mat FractalMarkerSet::getFractalMarkerImage(int pixSize, bool border) + { + if(fractalMarkerCollection.size()<1) + throw cv::Exception(9001, "There is not any fractal marker loaded", + "FractalMarkerSet::getFractalMarkerImage", __FILE__, __LINE__); + + //Smallest fractal marker + FractalMarker innerM = (--fractalMarkerCollection.end())->second; + float bitSize = innerM.getMarkerSize() / (pixSize * (sqrt(innerM.nBits())+2)); + + FractalMarker externMarker = fractalMarkerCollection[_idExternal]; + float markerSize = externMarker.getMarkerSize()/bitSize; + float markerBitSize = markerSize/(sqrt(externMarker.nBits())+2); + cv::Mat img=cv::Mat::zeros(markerSize, markerSize, CV_8U); + + //Asign value pixels + cv::Mat m = externMarker.mat(); + + for (int y = m.cols-1; y >=0 ; y--) + for (int x = m.cols-1; x >=0; x--){ + if (m.at(y,x) == 1){ + cv::Range val1 = cv::Range((1+y)*markerBitSize,(y+2)*markerBitSize); + cv::Range val2 = cv::Range((1+x)*markerBitSize,(x+2)*markerBitSize); + + cv::Mat bit_pix=img(val1, val2); + bit_pix.setTo(cv::Scalar::all(255)); + } + } + + for(auto idSubmarker:externMarker.subMarkers()){ + std::vector idds; + idds.push_back(idSubmarker); + while(!idds.empty()) + { + idSubmarker = idds.back(); + idds.pop_back(); + + FractalMarker submarker = fractalMarkerCollection[idSubmarker]; + + cv::Mat m = submarker.mat(); + cv::Point3f coord = submarker.points[0]; + + float markerSize = submarker.getMarkerSize()/bitSize; + float markerBitSize = markerSize/(sqrt(submarker.nBits())+2); + + //Get position inside fractal marker + float offsetX = abs(coord.x - externMarker.points[0].x)/bitSize ; + float offsetY = abs(coord.y - externMarker.points[0].y)/bitSize; + + //Asign value pixels + for (int y = m.cols-1; y >=0 ; y--) + for (int x = m.cols-1; x >=0; x--){ + if (m.at(y,x) == 1){ + cv::Range val1 = cv::Range((1+y)*markerBitSize + offsetY,(2+y)*markerBitSize + offsetY); + cv::Range val2 = cv::Range((1+x)*markerBitSize + offsetX,(2+x)*markerBitSize + offsetX); + + cv::Mat bit_pix=img(val1, val2); + bit_pix.setTo(cv::Scalar::all(255)); + } + } + + //Add submarkers to draw + for(auto idsm:submarker.subMarkers()) + idds.push_back(idsm); + } + } + + if(border) + copyMakeBorder(img,img,markerBitSize,markerBitSize,markerBitSize,markerBitSize,cv::BORDER_CONSTANT,cv::Scalar::all(255)); + + return img; + } +}; + diff --git a/src/aruco/fractallabelers/fractalmarkerset.h b/src/aruco/fractallabelers/fractalmarkerset.h new file mode 100644 index 0000000..08fcf58 --- /dev/null +++ b/src/aruco/fractallabelers/fractalmarkerset.h @@ -0,0 +1,145 @@ +#ifndef _ARUCO_FractalMarkerset_H +#define _ARUCO_FractalMarkerset_H + +#include "fractalmarker.h" + +#include +#include +#include +#include "../aruco_export.h" + +namespace aruco { + class ARUCO_EXPORT FractalMarkerSet{ + public: + enum CONF_TYPES: + uint64_t{ + FRACTAL_2L_6 = 0, + FRACTAL_3L_6 = 1, + FRACTAL_4L_6 = 2, + FRACTAL_5L_6 = 3, + CUSTOM=4 // for used defined dictionaries (using load). + }; + + /** create set of markers + * @brief create + * @param regionsConfig {N(f1),K(f1)}{N(f2):K(f2)}...{N(fn):K(fn)} + * @param pixSize + */ + void create(std::vector> regionsConfig, float pixSize); + + /** configure bits of inner marker + * @brief configureMat + * @param nVal N region + * @param kVal K region + * @param maxIter Number of iteration + * @return Mat configurated marker + */ + cv::Mat configureMat(int nVal, int kVal, int maxIter=10000); + // computes the distance of a marker to itself + int dstMarker(const cv::Mat m); + + // computes distance between marker to marker + int dstMarkerToMarker(const cv::Mat m1, const cv::Mat m2); + + // computes distance between marker to set of markers + int dstMarkerToFractalDict(cv::Mat m); + + // saves to a binary stream + static void _toStream(FractalMarkerSet &configuration, std::ostream &str); + + // load from a binary stream + static void _fromStream(FractalMarkerSet &configuration, std::istream &str); + + static bool isPredefinedConfigurationString(std::string str); + + static std::string getTypeString(FractalMarkerSet::CONF_TYPES t); + + static CONF_TYPES getTypeFromString(std::string str); + + static FractalMarkerSet load(std::string info); + + static FractalMarkerSet loadPredefined(std::string info); + + static FractalMarkerSet loadPredefined(CONF_TYPES info); + + static FractalMarkerSet readFromFile(std::string path); + + // saves configuration to a text file + void saveToFile(cv::FileStorage& fs); + + //Fractal configuration. id_marker + std::map fractalMarkerCollection; + //Nbits_idmarkers + std::map> nbits_fractalMarkerIDs ; + + enum Fractal3DInfoType + { + NONE = -1, + PIX = 0, + METERS = 1, + NORM = 2 + }; // indicates if the data in Fractal is expressed in meters or in pixels + + /**Indicates if the corners are expressed in meters + */ + bool isExpressedInMeters() const + { + return mInfoType == METERS; + } + /**Indicates if the corners are expressed in meters + */ + bool isExpressedInPixels() const + { + return mInfoType == PIX; + } + /**Indicates if the corners are normalized. -1..1 external marker + */ + bool isNormalize() const + { + return mInfoType == NORM; + } + + //Normalize fractal marker. The corners will go on to take the values (-1,1)(1,1),(1,-1)(-1,-1) + FractalMarkerSet normalize(); + + //Convert marker to meters + FractalMarkerSet convertToMeters(float fractalSize_meters); + + static std::vector getConfigurations(); + + //Get fractal size (external marker) + float getFractalSize() const + { + FractalMarker externalMarker = fractalMarkerCollection.at(_idExternal); + return externalMarker.getMarkerSize(); + } + + //Get number of bits (external marker) + int nBits() const + { + FractalMarker externalMarker = fractalMarkerCollection.at(_idExternal); + return externalMarker.nBits(); + } + + // Check if m is a inner marker, and get its id. + bool isFractalMarker(cv::Mat &m, int nbits, int&id); + + // Get all inners corners + std::map> getInnerCorners(); + + cv::Mat getFractalMarkerImage(int pixSize, bool border=false); + + // variable indicates if the data is expressed in meters or in pixels or are normalized + int mInfoType;/* -1:NONE, 0:PIX, 1:METERS, 2:NORMALIZE*/ + + private: + // Number of levels + int _nmarkers; + //ID external marker + int _idExternal=0; + //Configuration dictionary + std::string config; + }; +} + +#endif \ No newline at end of file diff --git a/src/aruco/fractallabelers/fractalposetracker.cpp b/src/aruco/fractallabelers/fractalposetracker.cpp new file mode 100644 index 0000000..8b86356 --- /dev/null +++ b/src/aruco/fractallabelers/fractalposetracker.cpp @@ -0,0 +1,947 @@ +#include "fractalposetracker.h" +#include "../levmarq.h" +#include "../ippe.h" +#include "../aruco_export.h" +#include "../timers.h" + + +#include "opencv2/calib3d/calib3d.hpp" +#include "opencv2/highgui/highgui.hpp" +#include "../aruco_cvversioning.h" + +struct TimerAvrg{std::vector times;size_t curr=0,n; std::chrono::high_resolution_clock::time_point begin,end; TimerAvrg(int _n=30){n=_n;times.reserve(n); }inline void start(){begin= std::chrono::high_resolution_clock::now(); }inline void stop(){end= std::chrono::high_resolution_clock::now();double duration=double(std::chrono::duration_cast(end-begin).count())*1e-6;if ( times.size()=times.size()) curr=0;}}double getAvrg(){double sum=0;for(auto t:times) sum+=t;return sum/double(times.size());}}; +TimerAvrg Tref; + +namespace aruco { + + void drawKeyPoints(cv::Mat image, std::vector kpoints, bool text=false, bool norm=false) + { + for(auto &k:kpoints) + if(norm){ + k.pt.x = k.pt.x*image.cols/2+image.cols/2; + k.pt.y = -k.pt.y*image.cols/2+image.cols/2; + } + + cv::Mat out; + cv::cvtColor(image, out, CV_GRAY2BGR); + //drawKeypoints(image, kpoints, out, cv::Scalar(0,0,255), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS); + + cv::Scalar color; + for(auto kp:kpoints) + { + if(kp.class_id == -1 ) color = cv::Scalar(255,0,255); + if(kp.class_id == 0 ) color = cv::Scalar(0,0,255); + if(kp.class_id == 1 ) color = cv::Scalar(0,255,0); + if(kp.class_id == 2 ) color = cv::Scalar(255,0,0); + circle(out, kp.pt, 2, color,-1); + } + + if(text){ + int nkm=0; + for(auto kp:kpoints) + { + putText( out, std::to_string(nkm++), kp.pt, CV_FONT_HERSHEY_COMPLEX, 1, cv::Scalar(0, 0, 255), 2, 8 ); + } + } + +//#ifdef _DEBUG + imshow("KPoints", out); + cv::waitKey(); +//#endif + } + /* + * KeyPoint cornersubpixel + */ + void kcornerSubPix(const cv::Mat image, std::vector &kpoints){ + + std::vector points; + cv::KeyPoint::convert(kpoints, points); + +// cv::Size winSize = cv::Size(5, 5); +// cv::Size zeroZone = cv::Size( -1, -1 ); +// cv::TermCriteria criteria = cv::TermCriteria( cv::TermCriteria::MAX_ITER, 20, 2 ); + //cv::cornerSubPix(image, points, winSize, zeroZone, criteria); + cornerSubPix(image, points, cv::Size(4,4), cv::Size(-1, -1),cv::TermCriteria( cv::TermCriteria::MAX_ITER | cv::TermCriteria::EPS, 12, 0.005)); + + //Update kpoints + uint32_t i=0; + for(auto &k:kpoints){ + k.pt = points[i]; + i++; + } + } + + /* + * KeyPoints Filter. Delete kpoints with low response and duplicated. + */ + void kfilter(std::vector &kpoints) + { + float minResp = kpoints[0].response; + float maxResp = kpoints[0].response; + for (auto &p:kpoints){ + p.size=40; + if(p.response < minResp) minResp = p.response; + if(p.response > maxResp) maxResp = p.response; + } + float thresoldResp = (maxResp - minResp) * 0.20f + minResp; + + //Erase kepoints with low response (20%) + for (uint32_t i=0;i< kpoints.size(); i++) + if(kpoints[i].response < thresoldResp){ + kpoints.erase(kpoints.begin()+i); + i--; + } + + //Duplicated keypoints (closer) + for(uint32_t xi=0; xi markerDetector, int markerWarpPix) + { + //ScopedTimerEvents Timer("fractal-refinement"); + + std::vector imagePyramid = markerDetector->getImagePyramid(); + std::vector _ref_inner3d; + std::vector _ref_inner2d; + + cv::Mat _p_rvec; + _rvec.copyTo(_p_rvec); + cv::Mat _p_tvec; + _tvec.copyTo(_p_tvec); + + _rvec.convertTo(_rvec,CV_32F); + _tvec.convertTo(_tvec,CV_32F); + cv::Mat rot; + cv::Rodrigues(_rvec, rot); + + for (auto id_marker : _fractalMarker.fractalMarkerCollection) + { + //Check z value for 4 external corners + std::vector marker3d; + for(auto pt : id_marker.second.points) + { + cv::Point3f pn = pt/(_fractalMarker.getFractalSize()/2); + cv::Mat_ src(3,1,rot.type()); + src(0,0)=pn.x;src(1,0)=pn.y;src(2,0)=pn.z; + + cv::Mat cam_image_point = rot * src + _tvec; + cam_image_point = cam_image_point/cv::norm(cam_image_point); + + if(cam_image_point.at(2,0)>0.85f) + marker3d.push_back(pn); + else break; + } + + std::vector _inners3d; + std::vector _inners2d; + double area; + if(marker3d.size()<4) + { + if(_id_area.find(id_marker.first) != _id_area.end()) + area = _id_area[id_marker.first]; + + for(auto pt : _id_innerp3d[id_marker.first]) + { + cv::Mat_ src(3,1,_rvec.type()); + src(0,0)=pt.x;src(1,0)=pt.y;src(2,0)=pt.z; + + cv::Mat cam_image_point = rot * src +_tvec; + cam_image_point = cam_image_point/cv::norm(cam_image_point); + + if(cam_image_point.at(2,0)>0.85) + _inners3d.push_back(pt); + } + cv::projectPoints(_inners3d, _rvec, _tvec, + _cam_params.CameraMatrix, _cam_params.Distorsion, _inners2d); + } + else + { + std::vector marker2d; + cv::projectPoints(marker3d, _rvec, _tvec, + _cam_params.CameraMatrix, _cam_params.Distorsion, marker2d); + + cv::Point2f v01 = marker2d[1] - marker2d[0]; + cv::Point2f v03 = marker2d[3] - marker2d[0]; + float area1 = fabs(v01.x * v03.y - v01.y * v03.x); + cv::Point2f v21 = marker2d[1] - marker2d[2]; + cv::Point2f v23 = marker2d[3] - marker2d[2]; + float area2 = fabs(v21.x * v23.y - v21.y * v23.x); + + area = (area2 + area1) / 2.f; + _id_area[id_marker.first] = area; + + _inners3d = _id_innerp3d[id_marker.first]; + cv::projectPoints(_inners3d, _rvec, _tvec, _cam_params.CameraMatrix, _cam_params.Distorsion, _inners2d); + } + + size_t imgPyrIdx = 0; + auto markerWarpSize = (sqrt(id_marker.second.nBits())+2)*markerWarpPix; + float desiredarea = std::pow(static_cast(markerWarpSize), 2.f); + for (size_t p = 1; p < imagePyramid.size(); p++) + { + if (area/ pow(4, p) >= desiredarea) imgPyrIdx = p; + else break; + } + + float ratio = float(imagePyramid[imgPyrIdx].cols)/float(imagePyramid[0].cols); + + std::cout << "REFINE["<< id_marker.first <<"], imgPyrId:"< _inners2d_error; + if (ratio == 1 && area >= desiredarea){ + int halfwsize= 4*float(imagePyramid[imgPyrIdx].cols)/float(imagePyramid[imgPyrIdx].cols) +0.5 ; + + std::vector _inners2d_copy; + for(auto pt:_inners2d){ _inners2d_copy.push_back(pt);} + cornerSubPix(imagePyramid[imgPyrIdx], _inners2d, cv::Size(halfwsize,halfwsize), cv::Size(-1, -1),cv::TermCriteria( cv::TermCriteria::MAX_ITER | cv::TermCriteria::EPS, 12, 0.005)); + int idx=0; + for(auto pt:_inners2d) + { + _inners2d_error.push_back(sqrt(pow(_inners2d_copy[idx].x - pt.x,2) + pow(_inners2d_copy[idx].y - pt.y,2))); + idx++; + } + } + else if (ratio != 1 && area >= desiredarea){ + + std::vector _inners2d_copy; + for(auto &pt:_inners2d){ _inners2d_copy.push_back(pt); pt *=ratio;} + + std::vector> vpnts; + vpnts.push_back(_inners2d); + markerDetector->cornerUpsample(vpnts, imagePyramid[imgPyrIdx].size()); + + int idx=0; + for(auto pt:vpnts[0]) + { + _inners2d_error.push_back(sqrt(pow(_inners2d_copy[idx].x - pt.x,2) + pow(_inners2d_copy[idx].y - pt.y,2))); + _inners2d[idx++] = pt; + } + } + + //Elimina puntos que no son esquinas + if (area >= desiredarea) { + //We discard outliers. Points above limit Q3+3*(Q3-1) + std::vector_inners2d_error_copy; + for(auto err:_inners2d_error) + _inners2d_error_copy.push_back(err); + sort(_inners2d_error_copy.begin(), _inners2d_error_copy.end()); + int q1 = (_inners2d_error_copy.size()+1)/4; + int q3 = 3*(_inners2d_error_copy.size()+1)/4; + + double limit = _inners2d_error_copy[q3] + 3*(_inners2d_error_copy[q3]-_inners2d_error_copy[q1]); + + int wsize = 10; + for(int idx=0; idx<_inners2d.size(); idx++) + { + if(_inners2d_error[idx]>limit) + continue; + + float x= int(_inners2d[idx].x+0.5f); + float y= int(_inners2d[idx].y+0.5f); + + cv::Rect r= cv::Rect(x-wsize,y-wsize,wsize*2+1,wsize*2+1); + //Check boundaries + if(r.x<0 || r.x+r.width>imagePyramid[0].cols || r.y<0 || + r.y+r.height>imagePyramid[0].rows) continue; + + int endX=r.x+r.width; + int endY=r.y+r.height; + uchar minV=255,maxV=0; + for(int y=r.y; y(y); + for(int x=r.x; xptr[x]) minV=ptr[x]; + if(maxV4) + { + aruco::solvePnP(_ref_inner3d, _ref_inner2d, _cam_params.CameraMatrix, _cam_params.Distorsion,_rvec,_tvec); + +//#define _fractal_debug_inners +#ifdef _fractal_debug_inners + cv::Mat InImageCopy; + cv::cvtColor(imagePyramid[0], InImageCopy, CV_GRAY2RGB); + + //Show first position (estimation with detected markers) + std::vector preinnersPrj; + for (auto id_marker : _fractalMarker.fractalMarkerCollection) + { + cv::projectPoints(_id_innerp3d[id_marker.first], _p_rvec, _p_tvec, _cam_params.CameraMatrix, _cam_params.Distorsion, preinnersPrj); + for(auto pt:preinnersPrj) + cv::circle(InImageCopy, pt, 5, cv::Scalar(0,0,255),CV_FILLED); + } + + //Show first position with refinement + for(auto p:_ref_inner2d) + cv::circle(InImageCopy, p, 5, cv::Scalar(255,0,0),CV_FILLED); + + _rvec.convertTo(_rvec,CV_32F); + _tvec.convertTo(_tvec,CV_32F); + cv::Rodrigues(_rvec, rot); + + std::vector _inners; + for(auto pt : _inner_corners_3d) + { + cv::Mat_ src(3,1,rot.type()); + src(0,0)=pt.x;src(1,0)=pt.y;src(2,0)=pt.z; + + cv::Mat cam_image_point = rot * src + _tvec ; + cam_image_point = cam_image_point/cv::norm(cam_image_point); + + if(cam_image_point.at(2,0)>0.85f) + _inners.push_back(pt); + } + std::vector _inners_prj; + cv::projectPoints(_inners, _rvec, _tvec, + _cam_params.CameraMatrix, _cam_params.Distorsion, _inners_prj); + + //Show new projection using all inner points + for(auto pt:_inners_prj) + cv::circle(InImageCopy, pt, 5, cv::Scalar(0,255,0),CV_FILLED); + + cv::namedWindow("AA",cv::WINDOW_NORMAL); + imshow("AA", InImageCopy); + cv::waitKey(); +#endif + //Timer.add("solve"); + + return true; + } + else + return false; + } + + bool FractalPoseTracker::fractalInnerPose(const cv::Ptr markerDetector, const std::vector& vmarkers, bool refinement) + { + if(vmarkers.size()>0) + { + ScopedTimerEvents Timer("pnp"); + + std::cout << "[Case 1]"<< std::endl; + std::vector p2d; + std::vector p3d; + for (auto marker : vmarkers) + { + if (_fractalMarker.fractalMarkerCollection.find(marker.id) != _fractalMarker.fractalMarkerCollection.end()) + { + for (auto p : marker) + p2d.push_back(p); + + for (auto p : _fractalMarker.fractalMarkerCollection[marker.id].points) + p3d.push_back(p); + } + } + + //Initial pose estimation + aruco::solvePnP(p3d, p2d, _cam_params.CameraMatrix, _cam_params.Distorsion,_rvec,_tvec); + + Timer.add("solve"); + + //REFINE + if(refinement) { + bool ref = fractalRefinement(markerDetector); + Timer.add("refine-solution"); + + if(!ref)return false; + } + + return true; + } + else + { + if(!_rvec.empty()) + { + std::cout << "[Case 2]"<< std::endl; + + ScopedTimerEvents Timer("ransac"); + + std::vector innerPoints2d; + std::vector innerPoints3d; + + float radius=0; + cv::Mat rot; + _rvec.convertTo(_rvec,CV_32F); + _tvec.convertTo(_tvec,CV_32F); + cv::Rodrigues(_rvec, rot); + + //Getting the keypoints search radius + for(auto id_marker:_fractalMarker.fractalMarkerCollection) + { + std::vector marker2d; + std::vector marker3d; + for(auto pt:_fractalMarker.fractalMarkerCollection[id_marker.first].points) + { + cv::Mat_ src(3,1,rot.type()); + src(0,0)=pt.x;src(1,0)=pt.y;src(2,0)=pt.z; + cv::Mat cam_image_point = rot * src + _tvec ; + cam_image_point = cam_image_point/cv::norm(cam_image_point); + + if(cam_image_point.at(2,0)>0.85f) + marker3d.push_back(pt); + else break; + } + + if(marker3d.size()==4) + { + cv::projectPoints(marker3d, _rvec, _tvec, _cam_params.CameraMatrix, _cam_params.Distorsion, marker2d); + + //Find marker area + cv::Point2f v01 = marker2d[1] - marker2d[0]; + cv::Point2f v03 = marker2d[3] - marker2d[0]; + float area1 = fabs(v01.x * v03.y - v01.y * v03.x); + cv::Point2f v21 = marker2d[1] - marker2d[2]; + cv::Point2f v23 = marker2d[3] - marker2d[2]; + float area2 = fabs(v21.x * v23.y - v21.y * v23.x); + double area = (area2 + area1) / 2.f; + + auto markerWarpSize = (sqrt(_fractalMarker.fractalMarkerCollection[id_marker.first].nBits())+2)*10; + float desiredarea = std::pow(static_cast(markerWarpSize), 2.f); + if(area >= desiredarea) + { + for(auto pt:_id_innerp3d[id_marker.first]) + innerPoints3d.push_back(pt); + } + + if(radius == 0.f) + radius = sqrt(area)/(sqrt(id_marker.second.nBits())+2.f); + } + else + { + for(auto pt:_id_innerp3d[id_marker.first]) + innerPoints3d.push_back(pt); + } + } + + if(radius==0) radius = _preRadius; + _preRadius = radius; + + if(innerPoints3d.size() > 0 && radius > 0) + { + cv::projectPoints(innerPoints3d, _rvec, _tvec, _cam_params.CameraMatrix, _cam_params.Distorsion, innerPoints2d); + + cv::Mat region; + cv::Point2f offset; + float ratio; + ROI(markerDetector->getImagePyramid(), region, innerPoints2d, offset, ratio); + radius = radius * ratio; + Timer.add("roi"); + + + //std::cout << "radius: " << radius << std::endl; + +//#define _fractal_debug_region +#ifdef _fractal_debug_region + cv::Mat out; + cv::cvtColor(region, out, CV_GRAY2RGB); + for(uint32_t i=0; i kpoints; + cv::Ptr fd = cv::FastFeatureDetector::create(); + fd->detect(region, kpoints); + Timer.add("fast"); + + + if(kpoints.size() > 0) + { + //Filter kpoints (low response) and removing duplicated. + kfilter(kpoints); + Timer.add("fast-filter"); + + //Assign class to keypoints + assignClass(region, kpoints); + Timer.add("fast-class"); + +//#define _fractal_debug_classification +#ifdef _fractal_debug_classification + drawKeyPoints(region, kpoints); + //cv::waitKey(); +#endif + //Get keypoints with better response in a radius + picoflann::KdTreeIndex<2,PicoFlann_KeyPointAdapter> kdtreeImg; + kdtreeImg.build(kpoints); + std::vector>> inner_candidates; + for(uint idx=0; idx> res = kdtreeImg.radiusSearch(kpoints, innerPoints2d[idx], radius); + + std::vector candidates; + for(auto r:res){ + if(kpoints[r.first].class_id == _innerkpoints[idx].class_id) + candidates.push_back(r.first); + } + if(candidates.size() > 0) + inner_candidates.push_back(make_pair(idx, candidates)); + } + Timer.add("candidates"); + + cv::Mat bestModel = fractal_solve_ransac(innerPoints2d.size(), inner_candidates, kpoints); + Timer.add("find-solution"); + + if(!bestModel.empty()){ + std::vectorp3d; + std::vectorp2d; + + std::vector pnts, pntsDst; + cv::KeyPoint::convert(kpoints, pnts); + perspectiveTransform(pnts, pntsDst, bestModel); + for(uint32_t id=0; id> res = _kdtree.radiusSearch(_innerkpoints, pntsDst[id], _id_radius[0]); + + int i=0; + for(auto r:res) + { + uint32_t innerId = r.first; + double dist = sqrt(r.second); + + uint32_t fmarkerId = _innerkpoints[innerId].octave; + if(dist > _id_radius[fmarkerId]) + res.erase(res.begin()+i); + else i++; + } + if(res.size()>0){ + p3d.push_back(_innerp3d[res[0].first]); + p2d.push_back(cv::Point2f(kpoints[id].pt.x + offset.x, kpoints[id].pt.y + offset.y)/ratio); + } + } + + if(p3d.size() >= 4) + { + aruco::solvePnP(p3d, p2d, _cam_params.CameraMatrix, _cam_params.Distorsion, _rvec, _tvec); + Timer.add("solves"); + + if(refinement) { + fractalRefinement(markerDetector); + Timer.add("refine-solution"); + } + + return true; + } + } + } + } + } + _rvec = cv::Mat(); + _tvec = cv::Mat(); + + return false; + } + } + + void FractalPoseTracker::ROI(const std::vector imagePyramid, cv::Mat &img, std::vector &innerPoints2d, cv::Point2f &offset, float &ratio) + { + cv::Mat rot; + _rvec.convertTo(_rvec,CV_32F); + _tvec.convertTo(_tvec,CV_32F); + cv::Rodrigues(_rvec, rot); + + + //Biggest marker projection + std::vector biggest_p2d; + std::vector biggest_p3d; + for(int idx=0; idx<_fractalMarker.fractalMarkerCollection.size()&biggest_p3d.size()<4; idx++) + { + biggest_p3d.empty(); + for(auto c:_fractalMarker.fractalMarkerCollection[idx].points) + { + cv::Point3f pt = c/(_fractalMarker.getFractalSize()/2); + cv::Mat_ src(3,1,rot.type()); + src(0,0)=pt.x;src(1,0)=pt.y;src(2,0)=pt.z; + cv::Mat cam_image_point = rot * src + _tvec ; + cam_image_point = cam_image_point/cv::norm(cam_image_point); + + if(cam_image_point.at(2,0)>0.85f) + biggest_p3d.push_back(pt); + else break; + } + } + cv::projectPoints(biggest_p3d, _rvec, _tvec, _cam_params.CameraMatrix, _cam_params.Distorsion, biggest_p2d); + + //Smallest marker projection + std::vector smallest_p2d; + std::vector smallest_p3d; + auto marker_smallest = (--_fractalMarker.fractalMarkerCollection.end())->second; + for(auto pt:marker_smallest.points) + smallest_p3d.push_back(pt/(_fractalMarker.getFractalSize()/2)); + cv::projectPoints(smallest_p3d, _rvec, _tvec, _cam_params.CameraMatrix, _cam_params.Distorsion, smallest_p2d); + + //Smallest marker area + cv::Point2f v01 = smallest_p2d[1] - smallest_p2d[0]; + cv::Point2f v03 = smallest_p2d[3] - smallest_p2d[0]; + float area1 = fabs(v01.x * v03.y - v01.y * v03.x); + cv::Point2f v21 = smallest_p2d[1] - smallest_p2d[2]; + cv::Point2f v23 = smallest_p2d[3] - smallest_p2d[2]; + float area2 = fabs(v21.x * v23.y - v21.y * v23.x); + double area = (area2 + area1) / 2.f; + + + //Compute boundaries region + float border = sqrt(area)/sqrt(marker_smallest.nBits())+2; + int minX=imagePyramid[0].cols, minY=imagePyramid[0].rows, maxX=0, maxY=0; + for(auto p:biggest_p2d) + { + if(p.x < minX) minX = p.x-border; + if(p.x > maxX) maxX = p.x+border; + if(p.y < minY) minY = p.y-border; + if(p.y > maxY) maxY = p.y+border; + } + if(minX < 0) minX=0; + if(minY < 0) minY=0; + if(maxX > imagePyramid[0].cols) maxX=imagePyramid[0].cols; + if(maxY > imagePyramid[0].rows) maxY=imagePyramid[0].rows; + + + //Select imagePyramid + size_t imgPyrIdx = 0; + auto markerWarpSize = (sqrt(marker_smallest.nBits())+2)*10; + float desiredarea = std::pow(static_cast(markerWarpSize), 2.f); + for (size_t p = 1; p < imagePyramid.size(); p++) + { + if (area / pow(4, p) >= desiredarea) imgPyrIdx = p; + else break; + } + + ratio=float(imagePyramid[imgPyrIdx].cols)/float(imagePyramid[0].cols); + offset=cv::Point2i(minX, minY)*ratio; + cv::Rect region = cv::Rect(cv::Point2i(minX, minY)*ratio , cv::Point2i(maxX, maxY)*ratio); + img = imagePyramid[imgPyrIdx](region); + + for(auto &pt:innerPoints2d){ + pt.x = pt.x*ratio - region.x; + pt.y = pt.y*ratio - region.y; + } + } + + cv::Mat FractalPoseTracker::fractal_solve_ransac(int ninners, std::vector>> inner_kpnt, std::vector kpnts, uint32_t maxIter, float _minInliers, float _thresInliers) + { + std::vector pnts; + cv::KeyPoint::convert(kpnts, pnts); + + //Number randomly values selected + uint32_t numInliers=4; + //Number of inliers to consider it good model, stop iterating!!! + uint32_t thresInliers = uint32_t(ninners*_thresInliers); + //Enough number of inliers to consider the model as valid + uint32_t minInliers = uint32_t(ninners*_minInliers); + + //Number of inliers + uint32_t bestInliers = 0; + //Best model + cv::Mat bestH = cv::Mat(); + + //struct timespec ts; + // clock_gettime(CLOCK_MONOTONIC, &ts); + //srand((time_t)ts.tv_nsec); + + uint32_t count=0; + for(auto ik:inner_kpnt) + if(ik.second.size()>0) + count++; + if(count < minInliers) return cv::Mat(); + + uint32_t iter = 0; + do + { + std::vector> inliers; + while(inliers.size() < numInliers) + { + uint idx = rand()%inner_kpnt.size(); + uint id_dst = inner_kpnt[idx].first; + + uint idxc = rand()%inner_kpnt[idx].second.size(); + uint id_src = inner_kpnt[idx].second[idxc]; + + //avoid duplicate observations + bool exist=false; + for(auto in:inliers) + { + if( (in.first != id_dst) && (in.second !=id_src)) + continue; + else { + exist=true; + break; + } + } + + //if it is a new observation, add it! + if(!exist) inliers.push_back(std::make_pair(id_dst, id_src)); + } + + std::vector srcInliers; + std::vector dstInliers; + for(auto in:inliers){ + dstInliers.push_back(_innerkpoints[in.first].pt); + srcInliers.push_back(kpnts[in.second].pt); + } + //Fit model with initial random inliers + cv::Mat H = findHomography(srcInliers, dstInliers); + + if(!H.empty()) + { + std::vector> newInliers; + std::vector> newInliers2; + + std::vector dstNewInliers; + std::vector srcNewInliers; + std::vector pntsTranf; + perspectiveTransform(pnts, pntsTranf, H); + + for(uint idP=0; idP< pntsTranf.size(); idP++) + { + std::vector>res = _kdtree.radiusSearch(_innerkpoints, pntsTranf[idP], _id_radius[0]); + + int i=0; + for(auto r:res) + { + uint32_t innerId = r.first; + double dist = sqrt(r.second); + + uint32_t fmarkerId = _innerkpoints[innerId].octave; + if(dist > _id_radius[fmarkerId]) + res.erase(res.begin()+i); + else i++; + } + + if(res.size() > 0){ + //avoid duplicate observations + bool exist=false; + for(auto in:newInliers) + { + if(in.first != res[0].first) + continue; + else { + exist=true; + break; + } + } + //if it is a new observation and these belong to the same class, add it! + if(!exist) + { + if(_innerkpoints[res[0].first].class_id == kpnts[idP].class_id) + newInliers.push_back(std::make_pair(res[0].first, idP)); + } + } + } + if(newInliers.size() > bestInliers) + { + bestInliers = newInliers.size(); + bestH = H; + } + } + iter++; + } while(iter& kpoints, bool norm, int wsize) + { + if(im.type()!=CV_8UC1) + throw std::runtime_error("assignClass Input image must be 8UC1"); + int wsizeFull=wsize*2+1; + + cv::Mat labels = cv::Mat::zeros(wsize*2+1,wsize*2+1,CV_8UC1); + cv::Mat thresIm=cv::Mat(wsize*2+1,wsize*2+1,CV_8UC1); + + for(auto &kp:kpoints) + { + float x = kp.pt.x; + float y = kp.pt.y; + + //Convert point range from norm (-1,1) to (0,imageSize) + if(norm){ + x = x*im.cols/2+im.cols/2; + y = -y*im.cols/2+im.cols/2; + } + + x= int(x+0.5f); + y= int(y+0.5f); + + cv::Rect r= cv::Rect(x-wsize,y-wsize,wsize*2+1,wsize*2+1); + //Check boundaries + if(r.x<0 || r.x+r.width>im.cols || r.y<0 || + r.y+r.height>im.rows) continue; + + int endX=r.x+r.width; + int endY=r.y+r.height; + uchar minV=255,maxV=0; + for(int y=r.y; y(y); + for(int x=r.x; xptr[x]) minV=ptr[x]; + if(maxV( r.y+y)+r.x; + uchar *thresPtr= thresIm.ptr(y); + for(int x=0; xthres) { + nZ++; + thresPtr[x]=255; + } + else thresPtr[x]=0; + } + } + //set all to zero labels.setTo(cv::Scalar::all(0)); + for(int y=0; y(y); + for(int x=0; x unions; + for(int y=0; y(y); + uchar *labelsPtr=labels.ptr(y); + for(int x=0; x -1) + { + if(reg == thresPtr[x-1]) + lleft_px =labelsPtr[x-1]; + } + + if(y-1 > -1) + { + if(reg ==thresIm.ptr(y-1) [x] + )//thresIm.at(y-1, x) + ltop_px = labels.at(y-1, x); + } + + if(lleft_px==0 && ltop_px==0) + labelsPtr[x] = newLab++; + + else if(lleft_px!=0 && ltop_px!=0) + { + if(lleft_px < ltop_px) + { + labelsPtr[x] = lleft_px; + unions[ltop_px] = lleft_px; + } + else if(lleft_px > ltop_px) + { + labelsPtr[x] = ltop_px; + unions[lleft_px] = ltop_px; + } + else + {//IGuales + labelsPtr[x] = ltop_px; + } + } + else + { + if(lleft_px!=0) labelsPtr[x] = lleft_px; + else labelsPtr[x] = ltop_px; + } + } + } + + int nc= newLab-1 - unions.size(); + if(nc==2) + { + if(nZ > thresIm.total()-nZ) kp.class_id = 0; + else kp.class_id = 1; + } + else if (nc > 2) { + kp.class_id = 2; + } + } + } +} diff --git a/src/aruco/fractallabelers/fractalposetracker.h b/src/aruco/fractallabelers/fractalposetracker.h new file mode 100644 index 0000000..ac054e4 --- /dev/null +++ b/src/aruco/fractallabelers/fractalposetracker.h @@ -0,0 +1,107 @@ +#ifndef _ARUCO_FractalPosetracker_H +#define _ARUCO_FractalPosetracker_H + +#include +#include "../picoflann.h" +#include "../cameraparameters.h" +#include "../markerdetector.h" +#include "fractalmarkerset.h" +#include "../aruco_export.h" +namespace aruco { + struct PicoFlann_KeyPointAdapter{ + inline float operator( )(const cv::KeyPoint &elem, int dim)const { return dim==0?elem.pt.x:elem.pt.y; } + inline float operator( )(const cv::Point2f &elem, int dim)const { return dim==0?elem.x:elem.y; } + }; + + class ARUCO_EXPORT FractalPoseTracker + { + public: + FractalPoseTracker(); + /** init fractlPoseTracker parameters + * @brief setParams + * @param cam_params camera paremeters + * @param msconf FractalMarkerSet configuration + */ + void setParams(const CameraParameters& cam_params, const FractalMarkerSet& msconf); + /** estimate the pose of the fractal marker. + * @brief fractalInnerPose + * @param markerDetector + * @param detected markers + * @param refinement, use or not pose refinement. True by default. + * @return true if the pose is estimated and false otherwise. If not estimated, the parameters m.Rvec and m.Tvec + * and not set. + */ + bool fractalInnerPose(const cv::Ptr markerDetector, const std::vector& markers, bool refinement=true); + /** extraction of the region of the image where the marker is estimated to be based on the previous pose + * @brief ROI + * @param imagePyramid set images + * @param img original image. The image is scaled according to the selected pyramid image. + * @param innerPoints2d collection fractal inner points. The points are scaled according to the selected pyramid image. + * @param offset. Position of the upper inner corner of the marker. The offset is scaled according to the selected pyramid image. + * @param ratio selected scaling factor + */ + void ROI(const std::vector imagePyramid, cv::Mat &img, std::vector &innerPoints2d, cv::Point2f &offset, float &ratio); + /** classification of the corners of the marker + * @brief assignClass + * @param im image used in the classification + * @param kpoints to classify + * @param norm. Is it necessary to normalize keypoints? (-1 .. 1) + * @param wsize. Window size + */ + void assignClass(const cv::Mat &im, std::vector& kpoints, bool norm=false, int wsize=5); + + /** estimate the pose of the fractal marker. Method case 2, paper. + * @brief fractal_solve_ransac + * @param ninners (number of total inners points used) + * @param inner_kpnt matches (inner points - detected keypoints) + * @param kpnts keypoints + * @param maxIter maximum number of iterations + * @param _minInliers beta in paper + * @param _thresInliers alpha in paper + * @return Mat best model homography. + */ + cv::Mat fractal_solve_ransac(int ninners, std::vector>> inner_kpnt, std::vector kpnts, uint32_t maxIter=500, float _minInliers=0.35f, float _thresInliers=0.7f); + + /** Refinement of the internal points of the marker and pose estimation with these. + * @brief fractalRefinement + * @param markerDetector + * @param markerWarpPix. Optimal markerwarpPix used to select the image of the pyramid. Default value 10. + * @return true if the pose is estimated and false otherwise. If not estimated, the parameters m.Rvec and m.Tvec + * and not set. + */ + bool fractalRefinement(const cv::Ptr markerDetector, int markerWarpPix=10); + + // return the rotation vector. Returns an empty matrix if last call to estimatePose returned false + const cv::Mat getRvec() const + { + return _rvec; + } + + // return the translation vector. Returns an empty matrix if last call to estimatePose returned false + const cv::Mat getTvec() const + { + return _tvec; + } + // return all inner points from fractal marker + const std::vector getInner3d() + { + return _innerp3d; + } + //is the pose valid? + bool isPoseValid()const{return !_rvec.empty() && !_tvec.empty();} + + private: + FractalMarkerSet _fractalMarker; //FractalMarkerSet configuration + aruco::CameraParameters _cam_params; //Camera parameters. + cv::Mat _rvec, _tvec; // current poses + std::map> _id_innerp3d; //Id_marker-Inners_corners + std::vector _innerp3d; //All inners corners + std::vector _innerkpoints; //All inners keypoints + picoflann::KdTreeIndex<2,PicoFlann_KeyPointAdapter> _kdtree; + std::map _id_radius; //Idmarker_Radius(Optimus) + std::map _id_area; //Idmarker_projectedArea(Optimus) + float _preRadius = 0; //radius used previous iteration + }; +} + +#endif \ No newline at end of file diff --git a/src/aruco/ippe.cpp b/src/aruco/ippe.cpp index b083ef4..b72c781 100644 --- a/src/aruco/ippe.cpp +++ b/src/aruco/ippe.cpp @@ -1,37 +1,13 @@ -/** -Copyright 2017 Rafael Muñoz Salinas. All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are -permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, this list of - conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, this list - of conditions and the following disclaimer in the documentation and/or other materials - provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those of the -authors and should not be interpreted as representing official policies, either expressed -or implied, of Rafael Muñoz Salinas. -*/ - #include "ippe.h" -#include -#include +#include + +#include + using namespace cv; using namespace std; -namespace aruco { + + +namespace aruco { /****** * @@ -95,80 +71,175 @@ cv::Mat getRTMatrix(const cv::Mat& R_, const cv::Mat& T_, int forceType) vector solvePnP(const vector& objPoints, const std::vector& imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs) { + + cv::Mat Rvec, Tvec; - float markerLength = static_cast(cv::norm(objPoints[1] - objPoints[0])); - float reprojErr1, reprojErr2; + float reprojErr1, reprojErr2; cv::Mat Rvec2, Tvec2; - solvePoseOfCentredSquare(markerLength, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec, reprojErr1, Rvec2, - Tvec2, reprojErr2); + IPPE::PoseSolver Solver; + Solver.solveGeneric(objPoints, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec, reprojErr1, Rvec2, + Tvec2, reprojErr2); + return {getRTMatrix(Rvec, Tvec, CV_32F), getRTMatrix(Rvec2, Tvec2, CV_32F)}; } void solvePnP(const vector& objPoints, const std::vector& imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs,cv::Mat &rvec,cv::Mat &tvec) { - float markerLength = static_cast(cv::norm(objPoints[1] - objPoints[0])); - float reprojErr1, reprojErr2; + float reprojErr1, reprojErr2; cv::Mat Rvec2, Tvec2; - solvePoseOfCentredSquare(markerLength, imgPoints, cameraMatrix, distCoeffs, rvec, tvec, reprojErr1, Rvec2, - Tvec2, reprojErr2); + IPPE::PoseSolver Solver; + Solver.solveGeneric(objPoints, imgPoints, cameraMatrix, distCoeffs, rvec, tvec, reprojErr1, Rvec2, + Tvec2, reprojErr2); } + std::vector > solvePnP_(float size,const std::vector &imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs){ cv::Mat Rvec, Tvec, Rvec2,Tvec2; float reprojErr1, reprojErr2; - solvePoseOfCentredSquare(size, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec,reprojErr1,Rvec2,Tvec2,reprojErr2); - return {make_pair(getRTMatrix(Rvec,Tvec,CV_32F),reprojErr1), make_pair(getRTMatrix(Rvec2,Tvec2,CV_32F),reprojErr2) } ; + IPPE::PoseSolver Solver; + Solver.solveSquare(size,imgPoints,cameraMatrix,distCoeffs, Rvec, Tvec,reprojErr1,Rvec2,Tvec2,reprojErr2); + + return {make_pair(getRTMatrix(Rvec, Tvec, CV_32F), reprojErr1), + make_pair(getRTMatrix(Rvec2, Tvec2, CV_32F), reprojErr2)}; } + std::vector> solvePnP_(const std::vector& objPoints, const std::vector& imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs) { cv::Mat Rvec, Tvec; - float markerLength = static_cast(cv::norm(objPoints[1] - objPoints[0])); float reprojErr1, reprojErr2; cv::Mat Rvec2, Tvec2; - solvePoseOfCentredSquare(markerLength, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec, reprojErr1, Rvec2, - Tvec2, reprojErr2); + IPPE::PoseSolver Solver; + Solver.solveGeneric(objPoints, imgPoints, cameraMatrix, distCoeffs, Rvec, Tvec, reprojErr1, Rvec2, + Tvec2, reprojErr2); + + return {make_pair(getRTMatrix(Rvec, Tvec, CV_32F), reprojErr1), - make_pair(getRTMatrix(Rvec2, Tvec2, CV_32F), reprojErr2)}; + make_pair(getRTMatrix(Rvec2, Tvec2, CV_32F), reprojErr2)}; + +} } -void solvePoseOfCentredSquare(float squareLength, InputArray imagePoints, InputArray cameraMatrix, - InputArray distCoeffs, OutputArray _rvec1, OutputArray _tvec1, float& reprojErr1, - OutputArray _rvec2, OutputArray _tvec2, float& reprojErr2) +IPPE::PoseSolver::PoseSolver() { - cv::Mat undistortedPoints; // undistored version of imagePoints - cv::Mat modelPoints(4, 1, CV_32FC3); - // set coordinate system in the middle of the marker, with Z pointing out - modelPoints.ptr(0)[0] = Vec3f(-squareLength / 2.0f, squareLength / 2.0f, 0); - modelPoints.ptr(0)[1] = Vec3f(squareLength / 2.0f, squareLength / 2.0f, 0); - modelPoints.ptr(0)[2] = Vec3f(squareLength / 2.0f, -squareLength / 2.0f, 0); - modelPoints.ptr(0)[3] = Vec3f(-squareLength / 2.0f, -squareLength / 2.0f, 0); - - //(Ra,ta), (Rb,tb) are the two pose solutions from IPPE. - _rvec1.create(3, 1, CV_64FC1); - _tvec1.create(3, 1, CV_64FC1); - _rvec2.create(3, 1, CV_64FC1); - _tvec2.create(3, 1, CV_64FC1); - cv::Mat H, Ra, Rb, ta, tb; - cv::Mat tvec1 = _tvec1.getMat(); - cv::Mat rvec1 = _rvec1.getMat(); - cv::Mat tvec2 = _tvec2.getMat(); - cv::Mat rvec2 = _rvec2.getMat(); +} + +IPPE::PoseSolver::~PoseSolver() +{ + +} + +void IPPE::PoseSolver::solveGeneric(cv::InputArray _objectPoints, cv::InputArray _imagePoints, cv::InputArray _cameraMatrix, cv::InputArray _distCoeffs, + cv::OutputArray _rvec1, cv::OutputArray _tvec1, float& err1, cv::OutputArray _rvec2, cv::OutputArray _tvec2, float& err2) +{ + cv::Mat normalizedImagePoints; //undistored version of imagePoints - // undistort the image points (i.e. put them in normalized pixel coordinates). - undistortPoints(imagePoints, undistortedPoints, cameraMatrix, distCoeffs); + if (_cameraMatrix.empty()) { + //there is no camera matrix and image points are given in normalized pixel coordinates. + _imagePoints.copyTo(normalizedImagePoints); + } + else { + //undistort the image points (i.e. put them in normalized pixel coordinates): + cv::undistortPoints(_imagePoints, normalizedImagePoints, _cameraMatrix, _distCoeffs); + } - // compute the homography mapping the model's four corners to undistortedPoints - homographyFromSquarePoints(undistortedPoints, squareLength / 2.0f, H); + //solve: + cv::Mat Ma, Mb; + solveGeneric(_objectPoints, normalizedImagePoints, Ma, Mb); - // Compute the Jacobian J of the homography at (0,0): + //the two poses computed by IPPE (sorted): + cv::Mat M1, M2; + + //sort poses by reprojection error: + sortPosesByReprojError(_objectPoints, _imagePoints, _cameraMatrix, _distCoeffs, Ma, Mb, M1, M2, err1, err2); + + //fill outputs + rot2vec(M1.colRange(0, 3).rowRange(0, 3), _rvec1); + rot2vec(M2.colRange(0, 3).rowRange(0, 3), _rvec2); + + M1.colRange(3, 4).rowRange(0, 3).copyTo(_tvec1); + M2.colRange(3, 4).rowRange(0, 3).copyTo(_tvec2); +} + +void IPPE::PoseSolver::solveGeneric(cv::InputArray _objectPoints, cv::InputArray _normalizedInputPoints, + cv::OutputArray _Ma, cv::OutputArray _Mb) +{ + + //argument checking: + size_t n = _objectPoints.rows() * _objectPoints.cols(); //number of points + int objType = _objectPoints.type(); + int type_input = _normalizedInputPoints.type(); + assert((objType == CV_32FC3) | (objType == CV_64FC3)); + assert((type_input == CV_32FC2) | (type_input == CV_64FC2)); + assert((_objectPoints.rows() == 1) | (_objectPoints.cols() == 1)); + assert((_objectPoints.rows() >= 4) | (_objectPoints.cols() >= 4)); + assert((_normalizedInputPoints.rows() == 1) | (_normalizedInputPoints.cols() == 1)); + assert(static_cast(_objectPoints.rows() * _objectPoints.cols()) == n); + + cv::Mat normalizedInputPoints; + if (type_input == CV_32FC2) { + _normalizedInputPoints.getMat().convertTo(normalizedInputPoints, CV_64FC2); + } + else { + normalizedInputPoints = _normalizedInputPoints.getMat(); + } + + cv::Mat objectInputPoints; + if (type_input == CV_32FC3) { + _objectPoints.getMat().convertTo(objectInputPoints, CV_64FC3); + } + else { + objectInputPoints = _objectPoints.getMat(); + } + + cv::Mat canonicalObjPoints; + cv::Mat MmodelPoints2Canonical; + + //transform object points to the canonical position (zero centred and on the plane z=0): + makeCanonicalObjectPoints(objectInputPoints, canonicalObjPoints, MmodelPoints2Canonical); + + //compute the homography mapping the model's points to normalizedInputPoints + cv::Mat H; + HomographyHO::homographyHO(canonicalObjPoints, _normalizedInputPoints, H); + + //now solve + cv::Mat MaCanon, MbCanon; + solveCanonicalForm(canonicalObjPoints, normalizedInputPoints, H, MaCanon, MbCanon); + + //transform computed poses to account for canonical transform: + cv::Mat Ma = MaCanon * MmodelPoints2Canonical; + cv::Mat Mb = MbCanon * MmodelPoints2Canonical; + + //output poses: + Ma.copyTo(_Ma); + Mb.copyTo(_Mb); +} + +void IPPE::PoseSolver::solveCanonicalForm(cv::InputArray _canonicalObjPoints, cv::InputArray _normalizedInputPoints, cv::InputArray _H, + cv::OutputArray _Ma, cv::OutputArray _Mb) +{ + + _Ma.create(4, 4, CV_64FC1); + _Mb.create(4, 4, CV_64FC1); + + cv::Mat Ma = _Ma.getMat(); + cv::Mat Mb = _Mb.getMat(); + cv::Mat H = _H.getMat(); + + //initialise poses: + Ma.setTo(0); + Ma.at(3, 3) = 1; + Mb.setTo(0); + Mb.at(3, 3) = 1; + + //Compute the Jacobian J of the homography at (0,0): double j00, j01, j10, j11, v0, v1; j00 = H.at(0, 0) - H.at(2, 0) * H.at(0, 2); @@ -176,165 +247,142 @@ void solvePoseOfCentredSquare(float squareLength, InputArray imagePoints, InputA j10 = H.at(1, 0) - H.at(2, 0) * H.at(1, 2); j11 = H.at(1, 1) - H.at(2, 1) * H.at(1, 2); - // Compute the transformation of (0,0) into the image: + //Compute the transformation of (0,0) into the image: v0 = H.at(0, 2); v1 = H.at(1, 2); - // compute the two rotation solutions: - IPPComputeRotations(j00, j01, j10, j11, v0, v1, Ra, Rb); + //compute the two rotation solutions: + cv::Mat Ra = Ma.colRange(0, 3).rowRange(0, 3); + cv::Mat Rb = Mb.colRange(0, 3).rowRange(0, 3); + computeRotations(j00, j01, j10, j11, v0, v1, Ra, Rb); - // for each rotation solution, compute the corresponding translation solution: - IPPComputeTranslation(modelPoints, undistortedPoints, Ra, ta); - IPPComputeTranslation(modelPoints, undistortedPoints, Rb, tb); + //for each rotation solution, compute the corresponding translation solution: + cv::Mat ta = Ma.colRange(3, 4).rowRange(0, 3); + cv::Mat tb = Mb.colRange(3, 4).rowRange(0, 3); + computeTranslation(_canonicalObjPoints, _normalizedInputPoints, Ra, ta); + computeTranslation(_canonicalObjPoints, _normalizedInputPoints, Rb, tb); +} - float reprojErra = IPPEvalReprojectionError(Ra, ta, modelPoints, undistortedPoints); - float reprojErrb = IPPEvalReprojectionError(Rb, tb, modelPoints, undistortedPoints); +void IPPE::PoseSolver::solveSquare(float squareLength, InputArray _imagePoints, InputArray _cameraMatrix, InputArray _distCoeffs, + OutputArray _rvec1, OutputArray _tvec1, float& err1, OutputArray _rvec2, OutputArray _tvec2, float& err2) +{ - if (reprojErra < reprojErrb) - { - tvec1.at(0) = ta.at(0); - tvec1.at(1) = ta.at(1); - tvec1.at(2) = ta.at(2); - IPPERot2vec(Ra, rvec1); + //allocate outputs: + _rvec1.create(3, 1, CV_64FC1); + _tvec1.create(3, 1, CV_64FC1); + _rvec2.create(3, 1, CV_64FC1); + _tvec2.create(3, 1, CV_64FC1); - tvec2.at(0) = tb.at(0); - tvec2.at(1) = tb.at(1); - tvec2.at(2) = tb.at(2); - IPPERot2vec(Rb, rvec2); + cv::Mat normalizedInputPoints; //undistored version of imagePoints + cv::Mat objectPoints2D; + + //generate the object points: + generateSquareObjectCorners2D(squareLength, objectPoints2D); - reprojErr1 = reprojErra; - reprojErr2 = reprojErrb; - } - else - { - tvec1.at(0) = tb.at(0); - tvec1.at(1) = tb.at(1); - tvec1.at(2) = tb.at(2); - IPPERot2vec(Rb, rvec1); - tvec2.at(0) = ta.at(0); - tvec2.at(1) = ta.at(1); - tvec2.at(2) = ta.at(2); - IPPERot2vec(Ra, rvec2); + cv::Mat H; //homography from canonical object points to normalized pixels - reprojErr1 = reprojErrb; - reprojErr2 = reprojErra; + + if (_cameraMatrix.empty()) { + //this means imagePoints are defined in normalized pixel coordinates, so just copy it: + _imagePoints.copyTo(normalizedInputPoints); + } + else { + //undistort the image points (i.e. put them in normalized pixel coordinates). + cv::undistortPoints(_imagePoints, normalizedInputPoints, _cameraMatrix, _distCoeffs); } -} -int IPPEvalBestPose(InputArray _R1, InputArray _R2, InputArray _t1, InputArray _t2, InputArray _objectPoints, - InputArray _undistortedPoints) -{ - cv::Mat modelPoints = _objectPoints.getMat(); - cv::Mat imgPoints = _undistortedPoints.getMat(); + //compute H + homographyFromSquarePoints(normalizedInputPoints, squareLength / 2.0f, H); - cv::Mat R1 = _R1.getMat(); - cv::Mat t1 = _t1.getMat(); + //now solve + cv::Mat Ma, Mb; + solveCanonicalForm(objectPoints2D, normalizedInputPoints, H, Ma, Mb); - cv::Mat R2 = _R2.getMat(); - cv::Mat t2 = _t2.getMat(); + //sort poses according to reprojection error: + cv::Mat M1, M2; + cv::Mat objectPoints3D; + generateSquareObjectCorners3D(squareLength, objectPoints3D); + sortPosesByReprojError(objectPoints3D, _imagePoints, _cameraMatrix, _distCoeffs, Ma, Mb, M1, M2, err1, err2); - int numPts = modelPoints.rows; + //fill outputs + rot2vec(M1.colRange(0, 3).rowRange(0, 3), _rvec1); + rot2vec(M2.colRange(0, 3).rowRange(0, 3), _rvec2); - // now loop over each correspondence and compute the reprojection error of both pose solution - float px, py, pz; - float reprojError1 = 0; // reprojection error of pose 1 - float reprojError2 = 0; // reprojection error of pose 2 + M1.colRange(3, 4).rowRange(0, 3).copyTo(_tvec1); + M2.colRange(3, 4).rowRange(0, 3).copyTo(_tvec2); +} - float dx, dy; // residual reprojection error with respect to x and y coordinates - for (int i = 0; i < numPts; i++) - { - // projection with first pose solution: - px = static_cast(R1.at(0, 0) * modelPoints.at(i)(0)) + - static_cast(R1.at(0, 1) * modelPoints.at(i)(1)) + - static_cast(R1.at(0, 2) * modelPoints.at(i)(2) + t1.at(0)); - py = static_cast(R1.at(1, 0) * modelPoints.at(i)(0)) + - static_cast(R1.at(1, 1) * modelPoints.at(i)(1)) + - static_cast(R1.at(1, 2) * modelPoints.at(i)(2) + t1.at(1)); - pz = static_cast(R1.at(2, 0) * modelPoints.at(i)(0)) + - static_cast(R1.at(2, 1) * modelPoints.at(i)(1)) + - static_cast(R1.at(2, 2) * modelPoints.at(i)(2) + t1.at(2)); - - dx = px / pz - imgPoints.at(i)(0); - dy = py / pz - imgPoints.at(i)(1); - - reprojError1 = reprojError1 + sqrt(dx * dx + dy * dy); - - // projection with second pose solution: - px = static_cast(R2.at(0, 0) * modelPoints.at(i)(0)) + - static_cast(R2.at(0, 1) * modelPoints.at(i)(1)) + - static_cast(R2.at(0, 2) * modelPoints.at(i)(2) + t2.at(0)); - py = static_cast(R2.at(1, 0) * modelPoints.at(i)(0)) + - static_cast(R2.at(1, 1) * modelPoints.at(i)(1)) + - static_cast(R2.at(1, 2) * modelPoints.at(i)(2) + t2.at(1)); - pz = static_cast(R2.at(2, 0) * modelPoints.at(i)(0)) + - static_cast(R2.at(2, 1) * modelPoints.at(i)(1)) + - static_cast(R2.at(2, 2) * modelPoints.at(i)(2) + t2.at(2)); - - dx = px / pz - imgPoints.at(i)(0); - dy = py / pz - imgPoints.at(i)(1); - - reprojError2 = reprojError2 + sqrt(dx * dx + dy * dy); - } - if (reprojError1 < reprojError2) - { - return 1; - } - else - { - return 2; - } +void IPPE::PoseSolver::generateSquareObjectCorners3D(double squareLength, OutputArray _objectPoints) +{ + _objectPoints.create(1, 4, CV_64FC3); + cv::Mat objectPoints = _objectPoints.getMat(); + objectPoints.ptr(0)[0] = Vec3d(-squareLength / 2.0, squareLength / 2.0, 0.0); + objectPoints.ptr(0)[1] = Vec3d(squareLength / 2.0, squareLength / 2.0, 0.0); + objectPoints.ptr(0)[2] = Vec3d(squareLength / 2.0, -squareLength / 2.0, 0.0); + objectPoints.ptr(0)[3] = Vec3d(-squareLength / 2.0, -squareLength / 2.0, 0.0); } -float IPPEvalReprojectionError(InputArray _R, InputArray _t, InputArray _objectPoints, - InputArray _undistortedPoints) +void IPPE::PoseSolver::generateSquareObjectCorners2D(double squareLength, OutputArray _objectPoints) { - cv::Mat modelPoints = _objectPoints.getMat(); - cv::Mat imgPoints = _undistortedPoints.getMat(); + _objectPoints.create(1, 4, CV_64FC2); + cv::Mat objectPoints = _objectPoints.getMat(); + objectPoints.ptr(0)[0] = Vec2d(-squareLength / 2.0, squareLength / 2.0); + objectPoints.ptr(0)[1] = Vec2d(squareLength / 2.0, squareLength / 2.0); + objectPoints.ptr(0)[2] = Vec2d(squareLength / 2.0, -squareLength / 2.0); + objectPoints.ptr(0)[3] = Vec2d(-squareLength / 2.0, -squareLength / 2.0); +} - cv::Mat R = _R.getMat(); - cv::Mat t = _t.getMat(); - - int numPts = modelPoints.rows; - float px, py, pz; - float reprojError = 0; - float dx, dy; // residual reprojection error with respect to x and y coordinates - // now loop over each correspondence and compute the reprojection error - for (int i = 0; i < numPts; i++) - { - px = static_cast(R.at(0, 0) * modelPoints.at(i)(0)) + - static_cast(R.at(0, 1) * modelPoints.at(i)(1)) + - static_cast(R.at(0, 2) * modelPoints.at(i)(2) + t.at(0)); - py = static_cast(R.at(1, 0) * modelPoints.at(i)(0)) + - static_cast(R.at(1, 1) * modelPoints.at(i)(1)) + - static_cast(R.at(1, 2) * modelPoints.at(i)(2) + t.at(1)); - pz = static_cast(R.at(2, 0) * modelPoints.at(i)(0)) + - static_cast(R.at(2, 1) * modelPoints.at(i)(1)) + - static_cast(R.at(2, 2) * modelPoints.at(i)(2) + t.at(2)); - - dx = px / pz - imgPoints.at(i)(0); - dy = py / pz - imgPoints.at(i)(1); - - reprojError = reprojError + sqrt(dx * dx + dy * dy); - } - return reprojError; +double IPPE::PoseSolver::meanSceneDepth(InputArray _objectPoints, InputArray _rvec, InputArray _tvec) +{ + assert((_objectPoints.type() == CV_64FC3) | (_objectPoints.type() == CV_64FC3)); + + size_t n = _objectPoints.rows() * _objectPoints.cols(); + Mat R; + Mat q; + Rodrigues(_rvec, R); + double zBar = 0; + + for (size_t i = 0; i < n; i++) { + cv::Mat p(_objectPoints.getMat().at(i)); + q = R * p + _tvec.getMat(); + double z; + if (q.depth() == CV_64FC1) { + z = q.at(2); + } + else { + z = static_cast(q.at(2)); + } + zBar += z; + + //if (z <= 0) { + // std::cout << "Warning: object point " << i << " projects behind the camera! This should not be allowed. " << std::endl; + //} + } + return zBar / static_cast(n); } -void IPPERot2vec(InputArray _R, OutputArray _r) +void IPPE::PoseSolver::rot2vec(InputArray _R, OutputArray _r) { + assert(_R.type() == CV_64FC1); + assert(_R.rows() == 3); + assert(_R.cols() == 3); + + _r.create(3, 1, CV_64FC1); + cv::Mat R = _R.getMat(); cv::Mat rvec = _r.getMat(); + double trace = R.at(0, 0) + R.at(1, 1) + R.at(2, 2); double w_norm = acos((trace - 1.0) / 2.0); double c0, c1, c2; - double eps = std::numeric_limits::epsilon(); + double eps = std::numeric_limits::epsilon(); double d = 1 / (2 * sin(w_norm)) * w_norm; - if (w_norm < eps) // rotation is the identity + if (w_norm < eps) //rotation is the identity { rvec.setTo(0); } - else - { + else { c0 = R.at(2, 1) - R.at(1, 2); c1 = R.at(0, 2) - R.at(2, 0); c2 = R.at(1, 0) - R.at(0, 1); @@ -344,34 +392,44 @@ void IPPERot2vec(InputArray _R, OutputArray _r) } } -void IPPComputeTranslation(InputArray _objectPoints, InputArray _imgPoints, InputArray _R, OutputArray _t) +void IPPE::PoseSolver::computeTranslation(InputArray _objectPoints, InputArray _normalizedImgPoints, InputArray _R, OutputArray _t) { - // This is solved by building the linear system At = b, where t corresponds to the (ALL_DICTS) translation. - // This is then inverted with the associated normal equations to give t = inv(transpose(A)*A)*transpose(A)*b - // For efficiency we only store the coefficients of (transpose(A)*A) and (transpose(A)*b) - cv::Mat modelPoints = _objectPoints.getMat(); - cv::Mat imgPoints = _imgPoints.getMat(); - int numPts = modelPoints.rows; + //This is solved by building the linear system At = b, where t corresponds to the (unknown) translation. + //This is then inverted with the associated normal equations to give t = inv(transpose(A)*A)*transpose(A)*b + //For efficiency we only store the coefficients of (transpose(A)*A) and (transpose(A)*b) + + assert(_objectPoints.type() == CV_64FC2); + assert(_normalizedImgPoints.type() == CV_64FC2); + assert(_R.type() == CV_64FC1); + + assert((_R.rows() == 3) & (_R.cols() == 3)); + assert((_objectPoints.rows() == 1) | (_objectPoints.cols() == 1)); + assert((_normalizedImgPoints.rows() == 1) | (_normalizedImgPoints.cols() == 1)); + size_t n = _normalizedImgPoints.rows() * _normalizedImgPoints.cols(); + assert(n == static_cast(_objectPoints.rows() * _objectPoints.cols())); + + cv::Mat objectPoints = _objectPoints.getMat(); + cv::Mat imgPoints = _normalizedImgPoints.getMat(); _t.create(3, 1, CV_64FC1); cv::Mat R = _R.getMat(); - // coefficients of (transpose(A)*A) - double ATA00 = numPts; + //coefficients of (transpose(A)*A) + double ATA00 = n; double ATA02 = 0; - double ATA11 = numPts; + double ATA11 = n; double ATA12 = 0; double ATA20 = 0; double ATA21 = 0; double ATA22 = 0; - // coefficients of (transpose(A)*b) + //coefficients of (transpose(A)*b) double ATb0 = 0; double ATb1 = 0; double ATb2 = 0; - // S gives inv(transpose(A)*A)/det(A)^2 + //S gives inv(transpose(A)*A)/det(A)^2 double S00, S01, S02; double S10, S11, S12; double S20, S21, S22; @@ -381,24 +439,24 @@ void IPPComputeTranslation(InputArray _objectPoints, InputArray _imgPoints, Inpu double b2; double bx, by; - // now loop through each point and increment the coefficients: - for (int i = 0; i < numPts; i++) - { - rx = R.at(0, 0) * modelPoints.at(i)(0) + R.at(0, 1) * modelPoints.at(i)(1) - + R.at(0, 2) * modelPoints.at(i)(2); - ry = R.at(1, 0) * modelPoints.at(i)(0) + R.at(1, 1) * modelPoints.at(i)(1) - + R.at(1, 2) * modelPoints.at(i)(2); - rz = R.at(2, 0) * modelPoints.at(i)(0) + R.at(2, 1) * modelPoints.at(i)(1) - + R.at(2, 2) * modelPoints.at(i)(2); - a2 = -imgPoints.at(i)(0); - b2 = -imgPoints.at(i)(1); + //now loop through each point and increment the coefficients: + for (size_t i = 0; i < n; i++) { + rx = R.at(0, 0) * objectPoints.at(i)(0) + R.at(0, 1) * objectPoints.at(i)(1); + ry = R.at(1, 0) * objectPoints.at(i)(0) + R.at(1, 1) * objectPoints.at(i)(1); + rz = R.at(2, 0) * objectPoints.at(i)(0) + R.at(2, 1) * objectPoints.at(i)(1); + + a2 = -imgPoints.at(i)(0); + b2 = -imgPoints.at(i)(1); + ATA02 = ATA02 + a2; ATA12 = ATA12 + b2; ATA20 = ATA20 + a2; ATA21 = ATA21 + b2; ATA22 = ATA22 + a2 * a2 + b2 * b2; - bx = (imgPoints.at(i)(0)) * rz - rx; - by = (imgPoints.at(i)(1)) * rz - ry; + + bx = -a2 * rz - rx; + by = -b2 * rz - ry; + ATb0 = ATb0 + bx; ATb1 = ATb1 + by; ATb2 = ATb2 + a2 * bx + b2 * by; @@ -406,7 +464,7 @@ void IPPComputeTranslation(InputArray _objectPoints, InputArray _imgPoints, Inpu double detAInv = 1.0 / (ATA00 * ATA11 * ATA22 - ATA00 * ATA12 * ATA21 - ATA02 * ATA11 * ATA20); - // construct S: + //construct S: S00 = ATA11 * ATA22 - ATA12 * ATA21; S01 = ATA02 * ATA21; S02 = -ATA02 * ATA11; @@ -417,49 +475,51 @@ void IPPComputeTranslation(InputArray _objectPoints, InputArray _imgPoints, Inpu S21 = -ATA00 * ATA21; S22 = ATA00 * ATA11; - // solve t: + //solve t: Mat t = _t.getMat(); t.at(0) = detAInv * (S00 * ATb0 + S01 * ATb1 + S02 * ATb2); t.at(1) = detAInv * (S10 * ATb0 + S11 * ATb1 + S12 * ATb2); t.at(2) = detAInv * (S20 * ATb0 + S21 * ATb1 + S22 * ATb2); } -void IPPComputeRotations(double j00, double j01, double j10, double j11, double p, double q, OutputArray _R1, - OutputArray _R2) +void IPPE::PoseSolver::computeRotations(double j00, double j01, double j10, double j11, double p, double q, OutputArray _R1, OutputArray _R2) { - // Note that it is very hard to understand what is going on here from the code, so if you want to have a clear - // explanation then please refer to the IPPE paper (Algorithm 1 and its description). + //This is fairly optimized code which makes it hard to understand. The matlab code is certainly easier to read. _R1.create(3, 3, CV_64FC1); _R2.create(3, 3, CV_64FC1); double a00, a01, a10, a11, ata00, ata01, ata11, b00, b01, b10, b11, binv00, binv01, binv10, binv11; - double rv00, rv01, rv02, rv10, rv11, rv12, rv20, rv21, rv22; + //double rv00, rv01, rv02, rv10, rv11, rv12, rv20, rv21, rv22; double rtilde00, rtilde01, rtilde10, rtilde11; double rtilde00_2, rtilde01_2, rtilde10_2, rtilde11_2; double b0, b1, gamma, dtinv; - double s, t, sp, krs0, krs1, krs0_2, krs1_2, costh, sinth; - - s = sqrt(p * p + q * q + 1); - t = sqrt(p * p + q * q); - costh = 1 / s; - sinth = sqrt(1 - 1 / (s * s)); - - krs0 = p / t; - krs1 = q / t; - krs0_2 = krs0 * krs0; - krs1_2 = krs1 * krs1; - - rv00 = (costh - 1) * krs0_2 + 1; - rv01 = krs0 * krs1 * (costh - 1); - rv02 = krs0 * sinth; - rv10 = krs0 * krs1 * (costh - 1); - rv11 = (costh - 1) * krs1_2 + 1; - rv12 = krs1 * sinth; - rv20 = -krs0 * sinth; - rv21 = -krs1 * sinth; - rv22 = (costh - 1) * (krs0_2 + krs1_2) + 1; - - // setup the 2x2 SVD decomposition: + double sp; + + Mat Rv; + cv::Mat v(3,1,CV_64FC1); + v.at(0) = p; + v.at(1) = q; + v.at(2) = 1; + rotateVec2ZAxis(v,Rv); + Rv = Rv.t(); + + + //setup the 2x2 SVD decomposition: + double rv00, rv01, rv02; + double rv10, rv11, rv12; + double rv20, rv21, rv22; + rv00 = Rv.at(0,0); + rv01 = Rv.at(0,1); + rv02 = Rv.at(0,2); + + rv10 = Rv.at(1,0); + rv11 = Rv.at(1,1); + rv12 = Rv.at(1,2); + + rv20 = Rv.at(2,0); + rv21 = Rv.at(2,1); + rv22 = Rv.at(2,2); + b00 = rv00 - p * rv20; b01 = rv01 - p * rv21; b10 = rv10 - q * rv20; @@ -477,14 +537,14 @@ void IPPComputeRotations(double j00, double j01, double j10, double j11, double a10 = binv10 * j00 + binv11 * j10; a11 = binv10 * j01 + binv11 * j11; - // compute the largest singular value of A: + //compute the largest singular value of A: ata00 = a00 * a00 + a01 * a01; ata01 = a00 * a10 + a01 * a11; ata11 = a10 * a10 + a11 * a11; gamma = sqrt(0.5 * (ata00 + ata11 + sqrt((ata00 - ata11) * (ata00 - ata11) + 4.0 * ata01 * ata01))); - // reconstruct the full rotation matrices: + //reconstruct the full rotation matrices: rtilde00 = a00 / gamma; rtilde01 = a01 / gamma; rtilde10 = a10 / gamma; @@ -499,82 +559,611 @@ void IPPComputeRotations(double j00, double j01, double j10, double j11, double b1 = sqrt(-rtilde01_2 - rtilde11_2 + 1); sp = (-rtilde00 * rtilde01 - rtilde10 * rtilde11); - if (sp < 0) - { + if (sp < 0) { b1 = -b1; } - // save results: + //store results: Mat R1 = _R1.getMat(); Mat R2 = _R2.getMat(); R1.at(0, 0) = (rtilde00)*rv00 + (rtilde10)*rv01 + (b0)*rv02; R1.at(0, 1) = (rtilde01)*rv00 + (rtilde11)*rv01 + (b1)*rv02; - R1.at(0, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv00 + (b0 * rtilde01 - b1 * rtilde00) * rv01 - + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv02; + R1.at(0, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv00 + (b0 * rtilde01 - b1 * rtilde00) * rv01 + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv02; R1.at(1, 0) = (rtilde00)*rv10 + (rtilde10)*rv11 + (b0)*rv12; R1.at(1, 1) = (rtilde01)*rv10 + (rtilde11)*rv11 + (b1)*rv12; - R1.at(1, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv10 + (b0 * rtilde01 - b1 * rtilde00) * rv11 - + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv12; + R1.at(1, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv10 + (b0 * rtilde01 - b1 * rtilde00) * rv11 + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv12; R1.at(2, 0) = (rtilde00)*rv20 + (rtilde10)*rv21 + (b0)*rv22; R1.at(2, 1) = (rtilde01)*rv20 + (rtilde11)*rv21 + (b1)*rv22; - R1.at(2, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv20 + (b0 * rtilde01 - b1 * rtilde00) * rv21 - + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv22; + R1.at(2, 2) = (b1 * rtilde10 - b0 * rtilde11) * rv20 + (b0 * rtilde01 - b1 * rtilde00) * rv21 + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv22; R2.at(0, 0) = (rtilde00)*rv00 + (rtilde10)*rv01 + (-b0) * rv02; R2.at(0, 1) = (rtilde01)*rv00 + (rtilde11)*rv01 + (-b1) * rv02; - R2.at(0, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv00 + (b1 * rtilde00 - b0 * rtilde01) * rv01 - + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv02; + R2.at(0, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv00 + (b1 * rtilde00 - b0 * rtilde01) * rv01 + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv02; R2.at(1, 0) = (rtilde00)*rv10 + (rtilde10)*rv11 + (-b0) * rv12; R2.at(1, 1) = (rtilde01)*rv10 + (rtilde11)*rv11 + (-b1) * rv12; - R2.at(1, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv10 + (b1 * rtilde00 - b0 * rtilde01) * rv11 - + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv12; + R2.at(1, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv10 + (b1 * rtilde00 - b0 * rtilde01) * rv11 + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv12; R2.at(2, 0) = (rtilde00)*rv20 + (rtilde10)*rv21 + (-b0) * rv22; R2.at(2, 1) = (rtilde01)*rv20 + (rtilde11)*rv21 + (-b1) * rv22; - R2.at(2, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv20 + (b1 * rtilde00 - b0 * rtilde01) * rv21 - + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv22; + R2.at(2, 2) = (b0 * rtilde11 - b1 * rtilde10) * rv20 + (b1 * rtilde00 - b0 * rtilde01) * rv21 + (rtilde00 * rtilde11 - rtilde01 * rtilde10) * rv22; } -void homographyFromSquarePoints(InputArray _targetPts, double halfLength, OutputArray H_) + +void IPPE::PoseSolver::homographyFromSquarePoints(InputArray _targetPoints, double halfLength, OutputArray H_) { - cv::Mat pts = _targetPts.getMat(); + + assert((_targetPoints.type() == CV_32FC2) | (_targetPoints.type() == CV_64FC2)); + + cv::Mat pts = _targetPoints.getMat(); H_.create(3, 3, CV_64FC1); Mat H = H_.getMat(); - double p1x = -pts.at(0)(0); - double p1y = -pts.at(0)(1); - - double p2x = -pts.at(1)(0); - double p2y = -pts.at(1)(1); - - double p3x = -pts.at(2)(0); - double p3y = -pts.at(2)(1); - - double p4x = -pts.at(3)(0); - double p4y = -pts.at(3)(1); - - // analytic solution: - double detsInv = -1 / (halfLength * (p1x * p2y - p2x * p1y - p1x * p4y + p2x * p3y - p3x * p2y + p4x * p1y - + p3x * p4y - p4x * p3y)); - - H.at(0, 0) = detsInv * (p1x * p3x * p2y - p2x * p3x * p1y - p1x * p4x * p2y + p2x * p4x * p1y - - p1x * p3x * p4y + p1x * p4x * p3y + p2x * p3x * p4y - p2x * p4x * p3y); - H.at(0, 1) = detsInv * (p1x * p2x * p3y - p1x * p3x * p2y - p1x * p2x * p4y + p2x * p4x * p1y - + p1x * p3x * p4y - p3x * p4x * p1y - p2x * p4x * p3y + p3x * p4x * p2y); - H.at(0, 2) = - detsInv * halfLength * (p1x * p2x * p3y - p2x * p3x * p1y - p1x * p2x * p4y + p1x * p4x * p2y - p1x * p4x * p3y - + p3x * p4x * p1y + p2x * p3x * p4y - p3x * p4x * p2y); - H.at(1, 0) = detsInv * (p1x * p2y * p3y - p2x * p1y * p3y - p1x * p2y * p4y + p2x * p1y * p4y - - p3x * p1y * p4y + p4x * p1y * p3y + p3x * p2y * p4y - p4x * p2y * p3y); - H.at(1, 1) = detsInv * (p2x * p1y * p3y - p3x * p1y * p2y - p1x * p2y * p4y + p4x * p1y * p2y - + p1x * p3y * p4y - p4x * p1y * p3y - p2x * p3y * p4y + p3x * p2y * p4y); - H.at(1, 2) = - detsInv * halfLength * (p1x * p2y * p3y - p3x * p1y * p2y - p2x * p1y * p4y + p4x * p1y * p2y - p1x * p3y * p4y - + p3x * p1y * p4y + p2x * p3y * p4y - p4x * p2y * p3y); - H.at(2, 0) = - -detsInv * (p1x * p3y - p3x * p1y - p1x * p4y - p2x * p3y + p3x * p2y + p4x * p1y + p2x * p4y - p4x * p2y); - H.at(2, 1) = - detsInv * (p1x * p2y - p2x * p1y - p1x * p3y + p3x * p1y + p2x * p4y - p4x * p2y - p3x * p4y + p4x * p3y); + double p1x, p1y; + double p2x, p2y; + double p3x, p3y; + double p4x, p4y; + + if (_targetPoints.type() == CV_32FC2) { + p1x = -pts.at(0)(0); + p1y = -pts.at(0)(1); + + p2x = -pts.at(1)(0); + p2y = -pts.at(1)(1); + + p3x = -pts.at(2)(0); + p3y = -pts.at(2)(1); + + p4x = -pts.at(3)(0); + p4y = -pts.at(3)(1); + } + else { + p1x = -pts.at(0)(0); + p1y = -pts.at(0)(1); + + p2x = -pts.at(1)(0); + p2y = -pts.at(1)(1); + + p3x = -pts.at(2)(0); + p3y = -pts.at(2)(1); + + p4x = -pts.at(3)(0); + p4y = -pts.at(3)(1); + } + + //analytic solution: + double detsInv = -1 / (halfLength * (p1x * p2y - p2x * p1y - p1x * p4y + p2x * p3y - p3x * p2y + p4x * p1y + p3x * p4y - p4x * p3y)); + + H.at(0, 0) = detsInv * (p1x * p3x * p2y - p2x * p3x * p1y - p1x * p4x * p2y + p2x * p4x * p1y - p1x * p3x * p4y + p1x * p4x * p3y + p2x * p3x * p4y - p2x * p4x * p3y); + H.at(0, 1) = detsInv * (p1x * p2x * p3y - p1x * p3x * p2y - p1x * p2x * p4y + p2x * p4x * p1y + p1x * p3x * p4y - p3x * p4x * p1y - p2x * p4x * p3y + p3x * p4x * p2y); + H.at(0, 2) = detsInv * halfLength * (p1x * p2x * p3y - p2x * p3x * p1y - p1x * p2x * p4y + p1x * p4x * p2y - p1x * p4x * p3y + p3x * p4x * p1y + p2x * p3x * p4y - p3x * p4x * p2y); + H.at(1, 0) = detsInv * (p1x * p2y * p3y - p2x * p1y * p3y - p1x * p2y * p4y + p2x * p1y * p4y - p3x * p1y * p4y + p4x * p1y * p3y + p3x * p2y * p4y - p4x * p2y * p3y); + H.at(1, 1) = detsInv * (p2x * p1y * p3y - p3x * p1y * p2y - p1x * p2y * p4y + p4x * p1y * p2y + p1x * p3y * p4y - p4x * p1y * p3y - p2x * p3y * p4y + p3x * p2y * p4y); + H.at(1, 2) = detsInv * halfLength * (p1x * p2y * p3y - p3x * p1y * p2y - p2x * p1y * p4y + p4x * p1y * p2y - p1x * p3y * p4y + p3x * p1y * p4y + p2x * p3y * p4y - p4x * p2y * p3y); + H.at(2, 0) = -detsInv * (p1x * p3y - p3x * p1y - p1x * p4y - p2x * p3y + p3x * p2y + p4x * p1y + p2x * p4y - p4x * p2y); + H.at(2, 1) = detsInv * (p1x * p2y - p2x * p1y - p1x * p3y + p3x * p1y + p2x * p4y - p4x * p2y - p3x * p4y + p4x * p3y); H.at(2, 2) = 1.0; } + +void IPPE::PoseSolver::makeCanonicalObjectPoints(InputArray _objectPoints, OutputArray _canonicalObjPoints, OutputArray _MmodelPoints2Canonical) +{ + + int objType = _objectPoints.type(); + assert((objType == CV_64FC3) | (objType == CV_32FC3)); + + size_t n = _objectPoints.rows() * _objectPoints.cols(); + + _canonicalObjPoints.create(1, n, CV_64FC2); + _MmodelPoints2Canonical.create(4, 4, CV_64FC1); + + cv::Mat objectPoints = _objectPoints.getMat(); + cv::Mat canonicalObjPoints = _canonicalObjPoints.getMat(); + + cv::Mat UZero(3, n, CV_64FC1); + + double xBar = 0; + double yBar = 0; + double zBar = 0; + bool isOnZPlane = true; + for (size_t i = 0; i < n; i++) { + double x, y, z; + if (objType == CV_32FC3) { + x = static_cast(objectPoints.at(i)[0]); + y = static_cast(objectPoints.at(i)[1]); + z = static_cast(objectPoints.at(i)[2]); + } + else { + x = objectPoints.at(i)[0]; + y = objectPoints.at(i)[1]; + z = objectPoints.at(i)[2]; + + if (abs(z) > IPPE_SMALL) { + isOnZPlane = false; + } + } + xBar += x; + yBar += y; + zBar += z; + + UZero.at(0, i) = x; + UZero.at(1, i) = y; + UZero.at(2, i) = z; + } + xBar = xBar / (double)n; + yBar = yBar / (double)n; + zBar = zBar / (double)n; + + for (size_t i = 0; i < n; i++) { + UZero.at(0, i) -= xBar; + UZero.at(1, i) -= yBar; + UZero.at(2, i) -= zBar; + } + + cv::Mat MCenter(4, 4, CV_64FC1); + MCenter.setTo(0); + MCenter.at(0, 0) = 1; + MCenter.at(1, 1) = 1; + MCenter.at(2, 2) = 1; + MCenter.at(3, 3) = 1; + + MCenter.at(0, 3) = -xBar; + MCenter.at(1, 3) = -yBar; + MCenter.at(2, 3) = -zBar; + + if (isOnZPlane) { + //MmodelPoints2Canonical is given by MCenter + MCenter.copyTo(_MmodelPoints2Canonical); + for (size_t i = 0; i < n; i++) { + canonicalObjPoints.at(i)[0] = UZero.at(0, i); + canonicalObjPoints.at(i)[1] = UZero.at(1, i); + } + } + else { + cv::Mat UZeroAligned(3, n, CV_64FC1); + cv::Mat R; //rotation that rotates objectPoints to the plane z=0 + + if (!computeObjextSpaceR3Pts(objectPoints,R)) + { + //we could not compute R, problably because there is a duplicate point in {objectPoints(0),objectPoints(1),objectPoints(2)}. So we compute it with the SVD (which is slower): + computeObjextSpaceRSvD(UZero,R); + } + + UZeroAligned = R * UZero; + + for (size_t i = 0; i < n; i++) { + canonicalObjPoints.at(i)[0] = UZeroAligned.at(0, i); + canonicalObjPoints.at(i)[1] = UZeroAligned.at(1, i); + assert(abs(UZeroAligned.at(2, i))<=IPPE_SMALL); + } + + cv::Mat MRot(4, 4, CV_64FC1); + MRot.setTo(0); + MRot.at(3, 3) = 1; + + R.copyTo(MRot.colRange(0, 3).rowRange(0, 3)); + cv::Mat Mb = MRot * MCenter; + Mb.copyTo(_MmodelPoints2Canonical); + } +} + +void IPPE::PoseSolver::evalReprojError(cv::InputArray _objectPoints, cv::InputArray _imagePoints, cv::InputArray _cameraMatrix, cv::InputArray _distCoeffs, cv::InputArray _M, float& err) +{ + cv::Mat projectedPoints; + cv::Mat imagePoints = _imagePoints.getMat(); + cv::Mat r; + rot2vec(_M.getMat().colRange(0, 3).rowRange(0, 3), r); + + if (_cameraMatrix.empty()) { + //there is no camera matrix and image points are in normalized pixel coordinates + cv::Mat K(3, 3, CV_64FC1); + K.setTo(0); + K.at(0, 0) = 1; + K.at(1, 1) = 1; + K.at(2, 2) = 1; + cv::Mat kc; + cv::projectPoints(_objectPoints, r, _M.getMat().colRange(3, 4).rowRange(0, 3), K, kc, projectedPoints); + } + else { + cv::projectPoints(_objectPoints, r, _M.getMat().colRange(3, 4).rowRange(0, 3), _cameraMatrix, _distCoeffs, projectedPoints); + } + + err = 0; + size_t n = _objectPoints.rows() * _objectPoints.cols(); + + float dx, dy; + for (size_t i = 0; i < n; i++) { + if (projectedPoints.depth() == CV_32FC1) { + dx = projectedPoints.at(i)[0] - imagePoints.at(i)[0]; + dy = projectedPoints.at(i)[1] - imagePoints.at(i)[1]; + } + else { + dx = projectedPoints.at(i)[0] - imagePoints.at(i)[0]; + dy = projectedPoints.at(i)[1] - imagePoints.at(i)[1]; + } + + err += dx * dx + dy * dy; + } + err = sqrt(err / (2.0f * n)); } + +void IPPE::PoseSolver::sortPosesByReprojError(cv::InputArray _objectPoints, cv::InputArray _imagePoints, cv::InputArray _cameraMatrix, cv::InputArray _distCoeffs, cv::InputArray _Ma, cv::InputArray _Mb, cv::OutputArray _M1, cv::OutputArray _M2, float& err1, float& err2) +{ + float erra, errb; + evalReprojError(_objectPoints, _imagePoints, _cameraMatrix, _distCoeffs, _Ma, erra); + evalReprojError(_objectPoints, _imagePoints, _cameraMatrix, _distCoeffs, _Mb, errb); + if (erra < errb) { + err1 = erra; + _Ma.copyTo(_M1); + + err2 = errb; + _Mb.copyTo(_M2); + } + else { + err1 = errb; + _Mb.copyTo(_M1); + + err2 = erra; + _Ma.copyTo(_M2); + } +} + +void HomographyHO::normalizeDataIsotropic(cv::InputArray _Data, cv::OutputArray _DataN, cv::OutputArray _T, cv::OutputArray _Ti) +{ + cv::Mat Data = _Data.getMat(); + int numPoints = Data.rows * Data.cols; + assert((Data.rows == 1) | (Data.cols == 1)); + assert((Data.channels() == 2) | (Data.channels() == 3)); + assert(numPoints >= 4); + + int dataType = _Data.type(); + assert((dataType == CV_64FC2) | (dataType == CV_64FC3) | (dataType == CV_32FC2) | (dataType == CV_32FC3)); + + _DataN.create(2, numPoints, CV_64FC1); + + _T.create(3, 3, CV_64FC1); + _Ti.create(3, 3, CV_64FC1); + + cv::Mat DataN = _DataN.getMat(); + cv::Mat T = _T.getMat(); + cv::Mat Ti = _Ti.getMat(); + + _T.setTo(0); + _Ti.setTo(0); + + double xm, ym; + int numChannels = Data.channels(); + + xm = 0; + ym = 0; + for (int i = 0; i < numPoints; i++) { + if (numChannels == 2) { + if (dataType == CV_32FC2) { + xm = xm + Data.at(i)[0]; + ym = ym + Data.at(i)[1]; + } + else { + xm = xm + Data.at(i)[0]; + ym = ym + Data.at(i)[1]; + } + } + else { + if (dataType == CV_32FC3) { + xm = xm + Data.at(i)[0]; + ym = ym + Data.at(i)[1]; + } + else { + xm = xm + Data.at(i)[0]; + ym = ym + Data.at(i)[1]; + } + } + } + xm = xm / (double)numPoints; + ym = ym / (double)numPoints; + + double kappa = 0; + double xh, yh; + + for (int i = 0; i < numPoints; i++) { + + if (numChannels == 2) { + if (dataType == CV_32FC2) { + xh = Data.at(i)[0] - xm; + yh = Data.at(i)[1] - ym; + } + else { + xh = Data.at(i)[0] - xm; + yh = Data.at(i)[1] - ym; + } + } + else { + if (dataType == CV_32FC3) { + xh = Data.at(i)[0] - xm; + yh = Data.at(i)[1] - ym; + } + else { + xh = Data.at(i)[0] - xm; + yh = Data.at(i)[1] - ym; + } + } + + DataN.at(0, i) = xh; + DataN.at(1, i) = yh; + kappa = kappa + xh * xh + yh * yh; + } + double beta = sqrt(2 * numPoints / kappa); + DataN = DataN * beta; + + T.at(0, 0) = 1.0 / beta; + T.at(1, 1) = 1.0 / beta; + + T.at(0, 2) = xm; + T.at(1, 2) = ym; + + T.at(2, 2) = 1; + + Ti.at(0, 0) = beta; + Ti.at(1, 1) = beta; + + Ti.at(0, 2) = -beta * xm; + Ti.at(1, 2) = -beta * ym; + + Ti.at(2, 2) = 1; +} + +void HomographyHO::homographyHO(cv::InputArray _srcPoints, cv::InputArray _targPoints, cv::OutputArray _H) +{ + + _H.create(3, 3, CV_64FC1); + cv::Mat H = _H.getMat(); + + cv::Mat DataA, DataB, TA, TAi, TB, TBi; + + HomographyHO::normalizeDataIsotropic(_srcPoints, DataA, TA, TAi); + HomographyHO::normalizeDataIsotropic(_targPoints, DataB, TB, TBi); + + int n = DataA.cols; + assert(n == DataB.cols); + + cv::Mat C1(1, n, CV_64FC1); + cv::Mat C2(1, n, CV_64FC1); + cv::Mat C3(1, n, CV_64FC1); + cv::Mat C4(1, n, CV_64FC1); + + cv::Mat Mx(n, 3, CV_64FC1); + cv::Mat My(n, 3, CV_64FC1); + + double mC1, mC2, mC3, mC4; + mC1 = 0; + mC2 = 0; + mC3 = 0; + mC4 = 0; + + for (int i = 0; i < n; i++) { + C1.at(0, i) = -DataB.at(0, i) * DataA.at(0, i); + C2.at(0, i) = -DataB.at(0, i) * DataA.at(1, i); + C3.at(0, i) = -DataB.at(1, i) * DataA.at(0, i); + C4.at(0, i) = -DataB.at(1, i) * DataA.at(1, i); + + mC1 = mC1 + C1.at(0, i); + mC2 = mC2 + C2.at(0, i); + mC3 = mC3 + C3.at(0, i); + mC4 = mC4 + C4.at(0, i); + } + + mC1 = mC1 / n; + mC2 = mC2 / n; + mC3 = mC3 / n; + mC4 = mC4 / n; + + for (int i = 0; i < n; i++) { + Mx.at(i, 0) = C1.at(0, i) - mC1; + Mx.at(i, 1) = C2.at(0, i) - mC2; + Mx.at(i, 2) = -DataB.at(0, i); + + My.at(i, 0) = C3.at(0, i) - mC3; + My.at(i, 1) = C4.at(0, i) - mC4; + My.at(i, 2) = -DataB.at(1, i); + } + + cv::Mat DataAT, DataADataAT, DataADataATi, Pp, Bx, By, Ex, Ey, D; + + cv::transpose(DataA, DataAT); + DataADataAT = DataA * DataAT; + double dt = DataADataAT.at(0, 0) * DataADataAT.at(1, 1) - DataADataAT.at(0, 1) * DataADataAT.at(1, 0); + + DataADataATi = cv::Mat(2, 2, CV_64FC1); + DataADataATi.at(0, 0) = DataADataAT.at(1, 1) / dt; + DataADataATi.at(0, 1) = -DataADataAT.at(0, 1) / dt; + DataADataATi.at(1, 0) = -DataADataAT.at(1, 0) / dt; + DataADataATi.at(1, 1) = DataADataAT.at(0, 0) / dt; + + Pp = DataADataATi * DataA; + + Bx = Pp * Mx; + By = Pp * My; + + Ex = DataAT * Bx; + Ey = DataAT * By; + + D = cv::Mat(2 * n, 3, CV_64FC1); + cv::Mat DT, DDT; + + for (int i = 0; i < n; i++) { + D.at(i, 0) = Mx.at(i, 0) - Ex.at(i, 0); + D.at(i, 1) = Mx.at(i, 1) - Ex.at(i, 1); + D.at(i, 2) = Mx.at(i, 2) - Ex.at(i, 2); + + D.at(i + n, 0) = My.at(i, 0) - Ey.at(i, 0); + D.at(i + n, 1) = My.at(i, 1) - Ey.at(i, 1); + D.at(i + n, 2) = My.at(i, 2) - Ey.at(i, 2); + } + + cv::transpose(D, DT); + DDT = DT * D; + + cv::Mat S, U, V, h12, h45; + double h3, h6; + + cv::eigen(DDT, S, U); + + cv::Mat h789(3, 1, CV_64FC1); + h789.at(0, 0) = U.at(2, 0); + h789.at(1, 0) = U.at(2, 1); + h789.at(2, 0) = U.at(2, 2); + + h12 = -Bx * h789; + h45 = -By * h789; + + h3 = -(mC1 * h789.at(0, 0) + mC2 * h789.at(1, 0)); + h6 = -(mC3 * h789.at(0, 0) + mC4 * h789.at(1, 0)); + + H.at(0, 0) = h12.at(0, 0); + H.at(0, 1) = h12.at(1, 0); + H.at(0, 2) = h3; + + H.at(1, 0) = h45.at(0, 0); + H.at(1, 1) = h45.at(1, 0); + H.at(1, 2) = h6; + + H.at(2, 0) = h789.at(0, 0); + H.at(2, 1) = h789.at(1, 0); + H.at(2, 2) = h789.at(2, 0); + + H = TB * H * TAi; + H = H / H.at(2, 2); +} + + +void IPPE::PoseSolver::rotateVec2ZAxis(InputArray _a, OutputArray _Ra) +{ + _Ra.create(3,3,CV_64FC1); + Mat Ra = _Ra.getMat(); + + double ax = _a.getMat().at(0); + double ay = _a.getMat().at(1); + double az = _a.getMat().at(2); + + double nrm = sqrt(ax*ax + ay*ay + az*az); + ax = ax/nrm; + ay = ay/nrm; + az = az/nrm; + + double c = az; + + if (abs(1.0+c)< std::numeric_limits::epsilon()) + { + Ra.setTo(0.0); + Ra.at(0,0) = 1.0; + Ra.at(1,1) = 1.0; + Ra.at(2,2) = -1.0; + } + else + { + double d = 1.0/(1.0+c); + double ax2 = ax*ax; + double ay2 = ay*ay; + double axay = ax*ay; + + Ra.at(0,0) = - ax2*d + 1.0; + Ra.at(0,1) = -axay*d; + Ra.at(0,2) = -ax; + + Ra.at(1,0) = -axay*d; + Ra.at(1,1) = - ay2*d + 1.0; + Ra.at(1,2) = -ay; + + Ra.at(2,0) = ax; + Ra.at(2,1) = ay; + Ra.at(2,2) = 1.0 - (ax2 + ay2)*d; + } + + +} + +bool IPPE::PoseSolver::computeObjextSpaceR3Pts(InputArray _objectPoints, OutputArray R) +{ + bool ret; //return argument + double p1x,p1y,p1z; + double p2x,p2y,p2z; + double p3x,p3y,p3z; + + cv::Mat objectPoints = _objectPoints.getMat(); + size_t n = objectPoints.rows*objectPoints.cols; + if (objectPoints.type() == CV_32FC3) + { + p1x = objectPoints.at(0)[0]; + p1y = objectPoints.at(0)[1]; + p1z = objectPoints.at(0)[2]; + + p2x = objectPoints.at(1)[0]; + p2y = objectPoints.at(1)[1]; + p2z = objectPoints.at(1)[2]; + + p3x = objectPoints.at(2)[0]; + p3y = objectPoints.at(2)[1]; + p3z = objectPoints.at(2)[2]; + } + else + { + p1x = objectPoints.at(0)[0]; + p1y = objectPoints.at(0)[1]; + p1z = objectPoints.at(0)[2]; + + p2x = objectPoints.at(1)[0]; + p2y = objectPoints.at(1)[1]; + p2z = objectPoints.at(1)[2]; + + p3x = objectPoints.at(2)[0]; + p3y = objectPoints.at(2)[1]; + p3z = objectPoints.at(2)[2]; + } + + double nx = (p1y - p2y)*(p1z - p3z) - (p1y - p3y)*(p1z - p2z); + double ny = (p1x - p3x)*(p1z - p2z) - (p1x - p2x)*(p1z - p3z); + double nz = (p1x - p2x)*(p1y - p3y) - (p1x - p3x)*(p1y - p2y); + + double nrm = sqrt(nx*nx+ ny*ny + nz*nz); + if (nrm>IPPE_SMALL) + { + nx = nx/nrm; + ny = ny/nrm; + nz = nz/nrm; + cv::Mat v(3,1,CV_64FC1); + v.at(0) = nx; + v.at(1) = ny; + v.at(2) = nz; + rotateVec2ZAxis(v,R); + ret = true; + } + else + { + ret = false; + } + return ret; +} + +bool IPPE::PoseSolver::computeObjextSpaceRSvD(InputArray _objectPointsZeroMean, OutputArray _R) +{ + bool ret; //return argument + _R.create(3,3,CV_64FC1); + cv::Mat R = _R.getMat(); + + //we could not compute R with the first three points, so lets use the SVD + cv::SVD s; + cv::Mat W, U, VT; + s.compute(_objectPointsZeroMean.getMat() * _objectPointsZeroMean.getMat().t(), W, U, VT); + double s3 = W.at(2); + double s2 = W.at(1); + + //check if points are coplanar: + assert(s3 / s2 < IPPE_SMALL); + + R = U.t(); + if (cv::determinant(R) < 0) { //this ensures R is a rotation matrix and not a general unitary matrix: + R.at(2, 0) = -R.at(2, 0); + R.at(2, 1) = -R.at(2, 1); + R.at(2, 2) = -R.at(2, 2); + } + ret = true; + return ret; +} + diff --git a/src/aruco/ippe.h b/src/aruco/ippe.h index 99e739d..b4e6116 100644 --- a/src/aruco/ippe.h +++ b/src/aruco/ippe.h @@ -1,49 +1,12 @@ -// This is the core header file for IPPE. Infinitesimal Plane-based Pose Estimation (IPPE) is a very fast and accurate -// way to compute a camera's pose from a single image of a planar object using point correspondences. This has uses in -// several applications, including augmented reality, 3D tracking and pose estimation with planar markers, and 3D scene -// understanding. -// This package is free and covered by the BSD licence without any warranty. We hope you find this code useful and if so -// please cite our paper in your work: - -//@article{ year={2014}, issn={0920-5691}, journal={International Journal of Computer Vision}, volume={109}, number={3}, -//doi={10.1007/s11263-014-0725-5}, title={Infinitesimal Plane-Based Pose Estimation}, -//url={http://dx.doi.org/10.1007/s11263-014-0725-5}, publisher={Springer US}, keywords={Plane; Pose; SfM; PnP; -//Homography}, author={Collins, Toby and Bartoli, Adrien}, pages={252-286}, language={English} } - -// Please contact Toby (toby.collins@gmail.com) if you have any questions about the code, paper and IPPE. - -/** -Copyright 2017 Rafael Muñoz Salinas. All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are -permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, this list of - conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, this list - of conditions and the following disclaimer in the documentation and/or other materials - provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those of the -authors and should not be interpreted as representing official policies, either expressed -or implied, of Rafael Muñoz Salinas. -*/ - #ifndef _IPPE_H_ #define _IPPE_H_ -#include + +#include +#include #include "aruco_export.h" +#include + +#define IPPE_SMALL 1e-7 //a small constant used to test 'small' values close to zero. namespace aruco { @@ -58,118 +21,216 @@ namespace aruco const std::vector& imgPoints, cv::InputArray cameraMatrix, cv::InputArray distCoeffs); - /** @brief Finds the two possible poses of a square planar object given its four corner correspondences in an image - using IPPE. These poses are sorted so that the first one is the one with the lowest reprojection error. The second - pose is needed if the problem is ambiguous. The problem is ambiguous when the projection of the model is close to - affine, which in practice happens if it is small or viewed from a large distance. In these cases there are two pose - solutions that can correctly align the correspondences (up to noise), so it is impossible to select the right one - from just the reprojection error. IPPE gives you both the solutions, rather than just a single solution (which in - ambiguous cases would be wrong 50% of the time). Geometrically, the two poses roughly correspond to a reflection of - the model about a plane whose normal passes through the line-of-sight from the camera centre to the model's centre. - For more details about these ambiguities, please refer to the IPPE paper. - * - * It is possible to reject the second pose if its reprojection error is significantly worse than the first pose. - The correct way to do this is with a likelihood ratio test (https://en.wikipedia.org/wiki/Likelihood-ratio_test). +} +namespace IPPE { + +class PoseSolver { + +public: + + /** + * @brief PoseSolver constructor + */ + PoseSolver(); + + /** + * @brief PoseSolver destructor + */ + ~PoseSolver(); + + /** + * @brief Finds the two possible poses of a planar object given a set of correspondences and their respective reprojection errors. The poses are sorted with the first having the lowest reprojection error. + * @param _objectPoints Array of 4 or more coplanar object points defined in object coordinates. 1xN/Nx1 3-channel (float or double) where N is the number of points + * @param _imagePoints Array of corresponding image points, 1xN/Nx1 2-channel. This can either be in pixel coordinates or normalized pixel coordinates. + * @param _cameraMatrix Intrinsic camera matrix (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray() + * @param _distCoeffs Intrinsic camera distortion vector (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray() + * @param _rvec1 First rotation solution (3x1 rotation vector) + * @param _tvec1 First translation solution (3x1 vector) + * @param reprojErr1 Reprojection error of first solution + * @param _rvec2 Second rotation solution (3x1 rotation vector) + * @param _tvec2 Second translation solution (3x1 vector) + * @param reprojErr2 Reprojection error of second solution + */ + void solveGeneric(cv::InputArray _objectPoints, cv::InputArray _imagePoints, cv::InputArray _cameraMatrix, cv::InputArray _distCoeffs, + cv::OutputArray _rvec1, cv::OutputArray _tvec1, float& reprojErr1, cv::OutputArray _rvec2, cv::OutputArray _tvec2, float& reprojErr2); + + /** @brief Finds the two possible poses of a square planar object and their respective reprojection errors using IPPE. These poses are sorted so that the first one is the one with the lowest reprojection error. * - @param squareLength the squares's length (which is also it's width) in object coordinate units (e.g. millimeters, - meters, etc.) - The square is defined in object coordinates on the plane z=0 and centred at the origin. Therefore its four points in - object coordinates are given by: - point 0: [-squareLength / 2.0, squareLength / 2.0, 0] - point 1: [squareLength / 2.0, squareLength / 2.0, 0] - point 2: [squareLength / 2.0, -squareLength / 2.0, 0] - point 3: [-squareLength / 2.0, -squareLength / 2.0, 0] - @param imagePoints Array of four corresponding image points, 1x4/4x1 2-channel. Note that the points should be - ordered to correspond with points 0, 1, 2 and 3. - @param cameraMatrix Input camera matrix \f$A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}\f$ . - @param distCoeffs Input vector of distortion coefficients - \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of - 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are - assumed. - @param _rvec1 Output rotation vector (see Rodrigues ) for first pose. That, together with tvec , brings points from - the model coordinate system to the camera coordinate system. - @param _tvec1 Output translation vector for first pose. - @param reprojErr1 Output reprojection error of first pose - @param _rvec2 Output rotation vector (see Rodrigues ) for second pose. That, together with tvec , brings points from - the model coordinate system to the camera coordinate system. - @param _tvec2 Output translation vector for second pose. - @param reprojErr1 Output reprojection error of second pose - - */ - void solvePoseOfCentredSquare(float squareLength, cv::InputArray imagePoints, cv::InputArray cameraMatrix, - cv::InputArray distCoeffs, cv::OutputArray _rvec1, cv::OutputArray _tvec1, - float& reprojErr1, cv::OutputArray _rvec2, cv::OutputArray _tvec2, float& reprojErr2); - - /** @brief Determines which of the two pose solutions from IPPE has the lowest reprojection error. - @param _R1 First rotation solution from IPPE, 3x3 1-channel float - @param _R2 Second rotation solution from IPPE 3x3 1-channel float - @param _t1 First translation solution from IPPE 3x1 1-channel float - @param _t2 Second translation solution from IPPE 3x3 1-channel float - @param _t2 Second translation solution from IPPE 3x1 1-channel float - @param _objectPoints Array of corresponding model points, 1xN/Nx1 3-channel where N is the number of points - @param _undistortedPoints Array of corresponding image points (undistorted and normalize), 1xN/Nx1 2-channel where N - is the number of points - */ - int IPPEvalBestPose(cv::InputArray _R1, cv::InputArray _R2, cv::InputArray _t1, cv::InputArray _t2, - cv::InputArray _objectPoints, cv::InputArray _undistortedPoints); - - /** @brief Determines the reprojection error of a pose solution - @param _R1 Rotation solution from IPPE, 3x3 1-channel float - @param _t Translation solution from IPPE 3x1 1-channel float - @param _objectPoints Array of corresponding model points, 1xN/Nx1 3-channel where N is the number of points - @param _undistortedPoints Array of corresponding image points (undistorted and normalized), 1xN/Nx1 2-channel where - N is the number of points - @return The pose solution with the lowest reprojection error. This is either 1 (first pose) or 2 (second pose) - */ - float IPPEvalReprojectionError(cv::InputArray _R, cv::InputArray _t, cv::InputArray _objectPoints, - cv::InputArray _undistortedPoints); - - /** @brief Fast conversion from a rotation matrix to a rotation vector using Rodrigues' formula - @param _R Rotation matrix, 3x3 1-channel float - @param _r Rotation vector, 3x1/1x3 1-channel float - */ - void IPPERot2vec(cv::InputArray _R, cv::OutputArray _r); - - /** @brief Computes the translation solution for a given rotation solution - @param _objectPoints Array of corresponding model points, 1xN/Nx1 3-channel where N is the number of points - @param _undistortedPoints Array of corresponding image points (undistorted), 1xN/Nx1 2-channel where N is the number - of points - @param _R1 Rotation solution from IPPE, 3x3 1-channel float - @param _t Translation solution, 3x1 1-channel float - */ - void IPPComputeTranslation(cv::InputArray _objectPoints, cv::InputArray _imgPoints, cv::InputArray _R, - cv::OutputArray _t); - - /** @brief Computes the two rotation solutions from the Jacobian of a homography matrix H. For highest accuracy the - Jacobian should be computed at the centroid of the point correspondences (see the IPPE paper for the explaination of - this). For a point (ux,uy) on the model plane, suppose the homography H maps (ux,uy) to a point (p,q) in the image - (in normalised pixel coordinates). The Jacobian matrix [J00, J01; J10,J11] is the Jacobian of the mapping evaluated - at (ux,uy). - @param j00 Jacobian coefficent - @param j01 Jacobian coefficent - @param j10 Jacobian coefficent - @param j11 Jacobian coefficent - @param p the x coordinate of point (ux,uy) mapped into the image (undistorted and normalised position) - @param q the y coordinate of point (ux,uy) mapped into the image (undistorted and normalised position) - */ - void IPPComputeRotations(double j00, double j01, double j10, double j11, double p, double q, cv::OutputArray _R1, - cv::OutputArray _R2); - - /** @brief Closed-form solution for the homography mapping with four corner correspondences of a square (it maps - source points to target points). The source points are the four corners of a zero-centred squared defined by: - * point 0: [-squareLength / 2.0, squareLength / 2.0] - point 1: [squareLength / 2.0, squareLength / 2.0] - point 2: [squareLength / 2.0, -squareLength / 2.0] - point 3: [-squareLength / 2.0, -squareLength / 2.0] + * @param _squareLength The square's length (which is also it's width) in object coordinate units (e.g. millimeters, meters, etc.) + * @param _imagePoints Array of corresponding image points, 1xN/Nx1 2-channel. This can either be in pixel coordinates or normalized pixel coordinates. + * @param _cameraMatrix Intrinsic camera matrix (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray() + * @param _distCoeffs Intrinsic camera distortion vector (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray() + * @param _rvec1 First rotation solution (3x1 rotation vector) + * @param _tvec1 First translation solution (3x1 vector) + * @param reprojErr1 Reprojection error of first solution + * @param _rvec2 Second rotation solution (3x1 rotation vector) + * @param _tvec2 Second translation solution (3x1 vector) + * @param reprojErr2 Reprojection error of second solution + */ + void solveSquare(float squareLength, cv::InputArray _imagePoints, cv::InputArray _cameraMatrix, cv::InputArray _distCoeffs, + cv::OutputArray _rvec1, cv::OutputArray _tvec1, float& reprojErr1, cv::OutputArray _rvec2, cv::OutputArray _tvec2, float& reprojErr2); + + /** + * @brief Generates the 4 object points of a square planar object + * @param squareLength The square's length (which is also it's width) in object coordinate units (e.g. millimeters, meters, etc.) + * @param _objectPoints Set of 4 object points (1x4 3-channel double) + */ + void generateSquareObjectCorners3D(double squareLength, cv::OutputArray _objectPoints); + + /** + * @brief Generates the 4 object points of a square planar object, without including the z-component (which is z=0 for all points). + * @param squareLength The square's length (which is also it's width) in object coordinate units (e.g. millimeters, meters, etc.) + * @param _objectPoints Set of 4 object points (1x4 2-channel double) + */ + void generateSquareObjectCorners2D(double squareLength, cv::OutputArray _objectPoints); + + /** + * @brief Computes the average depth of an object given its pose in camera coordinates + * @param objectPoints: Object points defined in 3D object space + * @param rvec: Rotation component of pose + * @param tvec: Translation component of pose + * @return: average depth of the object + */ + double meanSceneDepth(cv::InputArray objectPoints, cv::InputArray rvec, cv::InputArray tvec); + +private: + /** + * @brief Finds the two possible poses of a planar object given a set of correspondences in normalized pixel coordinates. These poses are **NOT** sorted on reprojection error. Note that the returned poses are object-to-camera transforms, and not camera-to-object transforms. + * @param _objectPoints Array of 4 or more coplanar object points defined in object coordinates. 1xN/Nx1 3-channel (float or double). + * @param _normalizedImagePoints Array of corresponding image points in normalized pixel coordinates, 1xN/Nx1 2-channel (float or double). + * @param _Ma First pose solution (unsorted) + * @param _Mb Second pose solution (unsorted) + */ + void solveGeneric(cv::InputArray _objectPoints, cv::InputArray _normalizedImagePoints, cv::OutputArray _Ma, cv::OutputArray _Mb); + + /** + * @brief Finds the two possible poses of a planar object in its canonical position, given a set of correspondences in normalized pixel coordinates. These poses are **NOT** sorted on reprojection error. Note that the returned poses are object-to-camera transforms, and not camera-to-object transforms. + * @param _canonicalObjPoints Array of 4 or more coplanar object points defined in object coordinates. 1xN/Nx1 3-channel (double) where N is the number of points + * @param _normalizedInputPoints Array of corresponding image points in normalized pixel coordinates, 1xN/Nx1 2-channel (double) where N is the number of points + * @param _H Homography mapping canonicalObjPoints to normalizedInputPoints. + * @param _Ma + * @param _Mb + */ + void solveCanonicalForm(cv::InputArray _canonicalObjPoints, cv::InputArray _normalizedInputPoints, cv::InputArray _H, + cv::OutputArray _Ma, cv::OutputArray _Mb); + + /** @brief Computes the translation solution for a given rotation solution + * @param _objectPoints Array of corresponding object points, 1xN/Nx1 3-channel where N is the number of points + * @param _normalizedImagePoints Array of corresponding image points (undistorted), 1xN/Nx1 2-channel where N is the number of points + * @param _R Rotation solution (3x1 rotation vector) + * @param _t Translation solution Translation solution (3x1 rotation vector) + */ + void computeTranslation(cv::InputArray _objectPoints, cv::InputArray _normalizedImgPoints, cv::InputArray _R, cv::OutputArray _t); + + /** @brief Computes the two rotation solutions from the Jacobian of a homography matrix H at a point (ux,uy) on the object plane. For highest accuracy the Jacobian should be computed at the centroid of the point correspondences (see the IPPE paper for the explanation of this). For a point (ux,uy) on the object plane, suppose the homography H maps (ux,uy) to a point (p,q) in the image (in normalized pixel coordinates). The Jacobian matrix [J00, J01; J10,J11] is the Jacobian of the mapping evaluated at (ux,uy). + * @param j00 Homography jacobian coefficent at (ux,uy) + * @param j01 Homography jacobian coefficent at (ux,uy) + * @param j10 Homography jacobian coefficent at (ux,uy) + * @param j11 Homography jacobian coefficent at (ux,uy) + * @param p the x coordinate of point (ux,uy) mapped into the image (undistorted and normalized position) + * @param q the y coordinate of point (ux,uy) mapped into the image (undistorted and normalized position) + */ + void computeRotations(double j00, double j01, double j10, double j11, double p, double q, cv::OutputArray _R1, cv::OutputArray _R2); + + /** @brief Closed-form solution for the homography mapping with four corner correspondences of a square (it maps source points to target points). The source points are the four corners of a zero-centred squared defined by: + * point 0: [-squareLength / 2.0, squareLength / 2.0] + * point 1: [squareLength / 2.0, squareLength / 2.0] + * point 2: [squareLength / 2.0, -squareLength / 2.0] + * point 3: [-squareLength / 2.0, -squareLength / 2.0] * - @param _targetPts Array of four corresponding target points, 1x4/4x1 2-channel. Note that the points should be - ordered to correspond with points 0, 1, 2 and 3. - @param halfLength the square's half length (i.e. squareLength/2.0) - @param _R1 Rotation solution from IPPE, 3x3 1-channel float - @param _H Homograhy mapping the source points to the target points, 3x3 single channel + * @param _targetPoints Array of four corresponding target points, 1x4/4x1 2-channel. Note that the points should be ordered to correspond with points 0, 1, 2 and 3. + * @param halfLength the square's half length (i.e. squareLength/2.0) + * @param _H Homograhy mapping the source points to the target points, 3x3 single channel + */ + void homographyFromSquarePoints(cv::InputArray _targetPoints, double halfLength, cv::OutputArray _H); + + /** @brief Fast conversion from a rotation matrix to a rotation vector using Rodrigues' formula + * @param _R Input rotation matrix, 3x3 1-channel (double) + * @param _r Output rotation vector, 3x1/1x3 1-channel (double) + */ + void rot2vec(cv::InputArray _R, cv::OutputArray _r); + + /** + * @brief Takes a set of planar object points and transforms them to 'canonical' object coordinates This is when they have zero mean and are on the plane z=0 + * @param _objectPoints Array of 4 or more coplanar object points defined in object coordinates. 1xN/Nx1 3-channel (float or double) where N is the number of points + * @param _canonicalObjectPoints Object points in canonical coordinates 1xN/Nx1 2-channel (double) + * @param _MobjectPoints2Canonical Transform matrix mapping _objectPoints to _canonicalObjectPoints: 4x4 1-channel (double) */ - void homographyFromSquarePoints(cv::InputArray _targetPts, double halfLength, cv::OutputArray _H); + void makeCanonicalObjectPoints(cv::InputArray _objectPoints, cv::OutputArray _canonicalObjectPoints, cv::OutputArray _MobjectPoints2Canonical); + + /** + * @brief Evaluates the Root Mean Squared (RMS) reprojection error of a pose solution. + * @param _objectPoints Array of 4 or more coplanar object points defined in object coordinates. 1xN/Nx1 3-channel (float or double) where N is the number of points + * @param _imagePoints Array of corresponding image points, 1xN/Nx1 2-channel. This can either be in pixel coordinates or normalized pixel coordinates. + * @param _cameraMatrix Intrinsic camera matrix (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray(). + * @param _distCoeffs Intrinsic camera distortion vector (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray(). + * @param _M Pose matrix from 3D object to camera coordinates: 4x4 1-channel (double) + * @param err RMS reprojection error + */ + void evalReprojError(cv::InputArray _objectPoints, cv::InputArray _imagePoints, cv::InputArray _cameraMatrix, cv::InputArray _distCoeffs, cv::InputArray _M, float& err); + + /** + * @brief Sorts two pose solutions according to their RMS reprojection error (lowest first). + * @param _objectPoints Array of 4 or more coplanar object points defined in object coordinates. 1xN/Nx1 3-channel (float or double) where N is the number of points + * @param _imagePoints Array of corresponding image points, 1xN/Nx1 2-channel. This can either be in pixel coordinates or normalized pixel coordinates. + * @param _cameraMatrix Intrinsic camera matrix (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray(). + * @param _distCoeffs Intrinsic camera distortion vector (same definition as OpenCV). If _imagePoints is in normalized pixel coordinates you must set _cameraMatrix = cv::noArray(). + * @param _Ma Pose matrix 1: 4x4 1-channel + * @param _Mb Pose matrix 2: 4x4 1-channel + * @param _M1 Member of (Ma,Mb} with lowest RMS reprojection error. Performs deep copy. + * @param _M2 Member of (Ma,Mb} with highest RMS reprojection error. Performs deep copy. + * @param err1 RMS reprojection error of _M1 + * @param err2 RMS reprojection error of _M2 + */ + void sortPosesByReprojError(cv::InputArray _objectPoints, cv::InputArray _imagePoints, cv::InputArray _cameraMatrix, cv::InputArray _distCoeffs, cv::InputArray _Ma, cv::InputArray _Mb, cv::OutputArray _M1, cv::OutputArray _M2, float& err1, float& err2); + /** + * @brief Finds the rotation _Ra that rotates a vector _a to the z axis (0,0,1) + * @param _a vector: 3x1 mat (double) + * @param _Ra Rotation: 3x3 mat (double) + */ + void rotateVec2ZAxis(cv::InputArray _a, cv::OutputArray _Ra); + + /** + * @brief Computes the rotation _R that rotates the object points to the plane z=0. This uses the cross-product method with the first three object points. + * @param _objectPoints Array of N>=3 coplanar object points defined in object coordinates. 1xN/Nx1 3-channel (float or double) where N is the number of points + * @param _R Rotation Mat: 3x3 (double) + * @return success (true) or failure (false) + */ + bool computeObjextSpaceR3Pts(cv::InputArray _objectPoints, cv::OutputArray _R); + + /** + * @brief computeObjextSpaceRSvD Computes the rotation _R that rotates the object points to the plane z=0. This uses the cross-product method with the first three object points. + * @param _objectPointsZeroMean zero-meaned co=planar object points: 3xN matrix (double) where N>=3 + * @param _R Rotation Mat: 3x3 (double) + * @return success (true) or failure (false) + */ + bool computeObjextSpaceRSvD(cv::InputArray _objectPointsZeroMean, cv::OutputArray _R); +}; } + +namespace HomographyHO { + +/** + * @brief Computes the best-fitting homography matrix from source to target points using Harker and O'Leary's method: + * Harker, M., O'Leary, P., Computation of Homographies, Proceedings of the British Machine Vision Conference 2005, Oxford, England. + * This is not the author's implementation. + * @param srcPoints Array of source points: 1xN/Nx1 2-channel (float or double) where N is the number of points + * @param targPoints Array of target points: 1xN/Nx1 2-channel (float or double) + * @param H Homography from source to target: 3x3 1-channel (double) + */ +void homographyHO(cv::InputArray srcPoints, cv::InputArray targPoints, cv::OutputArray H); + +/** + * @brief Performs data normalization before homography estimation. For details see Hartley, R., Zisserman, A., Multiple View Geometry in Computer Vision, + * Cambridge University Press, Cambridge, 2001 + * @param Data Array of source data points: 1xN/Nx1 2-channel (float or double) where N is the number of points + * @param DataN Normalized data points: 1xN/Nx1 2-channel (float or double) where N is the number of points + * @param T Homogeneous transform from source to normalized: 3x3 1-channel (double) + * @param Ti Homogeneous transform from normalized to source: 3x3 1-channel (double) + */ +void normalizeDataIsotropic(cv::InputArray Data, cv::OutputArray DataN, cv::OutputArray T, cv::OutputArray Ti); +} + #endif diff --git a/src/aruco/marker.cpp b/src/aruco/marker.cpp index 3daaaa4..0d37ecc 100644 --- a/src/aruco/marker.cpp +++ b/src/aruco/marker.cpp @@ -297,7 +297,7 @@ namespace aruco if(writeInfo) str+= dict_info +":"; if(writeId)str+=_to_string(id); cv::putText(in,str, cent, cv::FONT_HERSHEY_SIMPLEX, std::max(0.5f, float(lineWidth) * 0.3f), - cv::Scalar(255 - color[0], 255 - color[1], 255 - color[2], 255), std::max(lineWidth, 2)); + cv::Scalar(255,0, 255), std::max(lineWidth, 2)); } } @@ -472,5 +472,24 @@ namespace aruco str.read((char*)&contourPoints[0], contourPoints.size()*sizeof(contourPoints[0])); } + cv::Mat Marker::getTransformMatrix()const{ + + cv::Mat T=cv::Mat::eye(4,4,CV_32F); + cv::Mat rot=T.rowRange(0,3).colRange(0,3); + cv::Rodrigues(Rvec,rot); + for(int i=0;i<3;i++) + T.at(i,3)=Tvec.ptr(0)[i]; + return T; + } + + float Marker::getRadius()const{ + + auto center=getCenter(); + + float maxDist=0; + for(auto p:*this) + maxDist=std::max(maxDist, float(cv::norm(p-center)) ); + return maxDist; + } } diff --git a/src/aruco/marker.h b/src/aruco/marker.h index 1d998cf..c9ecea4 100644 --- a/src/aruco/marker.h +++ b/src/aruco/marker.h @@ -131,6 +131,9 @@ or implied, of Rafael Muñoz Salinas. /**Returns the area */ float getArea() const; + /**Returns radius of enclosing circle + */ + float getRadius()const; /**compares ids */ bool operator==(const Marker& m) const @@ -179,6 +182,9 @@ or implied, of Rafael Muñoz Salinas. return get3DPoints(ssize); } + //returns the SE3 (4x4) transform matrix + + cv::Mat getTransformMatrix()const; private: void rotateXAxis(cv::Mat& rotation); }; diff --git a/src/aruco/markerdetector.cpp b/src/aruco/markerdetector.cpp index 2b1e2a7..2369eba 100644 --- a/src/aruco/markerdetector.cpp +++ b/src/aruco/markerdetector.cpp @@ -41,11 +41,12 @@ or implied, of Rafael Muñoz Salinas. #include #include #include "debug.h" -//#include "picoflann.h" +#include "aruco_cvversioning.h" +#include "markerdetector_impl.h" -#ifdef _DEBUG -#include -#endif +//#ifdef _DEBUG +//#include +//#endif using namespace std; using namespace cv; @@ -59,8 +60,8 @@ namespace aruco ************************************/ MarkerDetector::MarkerDetector() { - markerIdDetector = aruco::MarkerLabeler::create(Dictionary::ALL_DICTS); - setDetectionMode(DM_NORMAL); + _impl=new MarkerDetector_Impl(); +// _iplm=std::unique_ptr(new MarkerDetector_Impl()); } /************************************ * @@ -69,6 +70,7 @@ MarkerDetector::MarkerDetector() * ************************************/ MarkerDetector::MarkerDetector(int dict_type, float error_correction_rate ){ + _impl=new MarkerDetector_Impl(); setDictionary(dict_type,error_correction_rate); setDetectionMode(DM_NORMAL); } @@ -79,6 +81,7 @@ MarkerDetector::MarkerDetector(int dict_type, float error_correction_rate ){ * ************************************/ MarkerDetector::MarkerDetector(std::string dict_type, float error_correction_rate ){ + _impl=new MarkerDetector_Impl(); setDictionary(dict_type,error_correction_rate); setDetectionMode(DM_NORMAL); @@ -92,11 +95,11 @@ MarkerDetector::MarkerDetector(std::string dict_type, float error_correction_rat MarkerDetector::~MarkerDetector() { + delete _impl; } void MarkerDetector::setParameters(const Params ¶ms){ - _params=params; - setDictionary(_params.dictionary,_params.error_correction_rate); + _impl->setParameters(params); } /************************************ @@ -106,1339 +109,70 @@ void MarkerDetector::setParameters(const Params ¶ms){ * ************************************/ void MarkerDetector::setDetectionMode( DetectionMode dm,float minMarkerSize){ - _params.setDetectionMode(dm,minMarkerSize); + _impl->_18062104616271777338.setDetectionMode(dm,minMarkerSize); } DetectionMode MarkerDetector::getDetectionMode( ){ -return _params.detectMode; +return _impl->_18062104616271777338.detectMode; } -/************************************ - * - * - * - * - ************************************/ - std::vector MarkerDetector::detect(const cv::Mat& input) { - std::vector detectedMarkers; - detect(input, detectedMarkers); - return detectedMarkers; + return _impl->detect(input); } std::vector MarkerDetector::detect(const cv::Mat& input, const CameraParameters& camParams, - float markerSizeMeters, - bool setYPerperdicular) -{ - std::vector detectedMarkers; - detect(input, detectedMarkers, camParams, markerSizeMeters, setYPerperdicular); - return detectedMarkers; -} - -/************************************ - * - * - * - * - ************************************/ -void MarkerDetector::detect(const cv::Mat& input, std::vector& detectedMarkers, CameraParameters camParams, - float markerSizeMeters, bool setYPerpendicular) -{ - if (camParams.CamSize != input.size() && camParams.isValid() && markerSizeMeters > 0) - { - // must resize camera parameters if we want to compute properly marker poses - CameraParameters cp_aux = camParams; - cp_aux.resize(input.size()); - detect(input, detectedMarkers, cp_aux.CameraMatrix, cp_aux.Distorsion, markerSizeMeters, setYPerpendicular); - } - else - { - detect(input, detectedMarkers, camParams.CameraMatrix, camParams.Distorsion, markerSizeMeters,setYPerpendicular); - } -} -int MarkerDetector::getMarkerWarpSize(){ - - auto bis=markerIdDetector->getBestInputSize(); - if ( bis!=-1) return bis; - - int ndiv= markerIdDetector->getNSubdivisions(); - if (ndiv==-1) ndiv=7;//set any possible value(it is used for non dictionary based labelers) - return _params.markerWarpPixSize*ndiv;//this is the minimum size that the smallest marker will have - -} - - - - - -void MarkerDetector::buildPyramid(vector &ImagePyramid,const cv::Mat &grey,int minSize){ - //determine numbre of pyramid images - int npyrimg=1; - cv::Size imgpsize=grey.size(); - while (imgpsize.width > minSize) { imgpsize=cv::Size(imgpsize.width/_params.pyrfactor,imgpsize.height/_params.pyrfactor) ;npyrimg++;} - - ImagePyramid.resize(npyrimg); - imagePyramid[0]=grey; - //now, create pyramid images - imgpsize=grey.size(); - for(int i=1;i& kpoints, bool norm, int wsize) - { - if(im.type()!=CV_8UC1)throw std::runtime_error("assignClass_fast Input image must be 8UC1"); - int wsizeFull=wsize*2+1; - - cv::Mat labels = cv::Mat::zeros(wsize*2+1,wsize*2+1,CV_8UC1); - cv::Mat thresIm=cv::Mat(wsize*2+1,wsize*2+1,CV_8UC1); - - for(auto &kp:kpoints) - { - int x = kp.pt.x+0.5f; - int y = kp.pt.y+0.5f; - - cv::Rect r= cv::Rect(x-wsize,y-wsize,wsize*2+1,wsize*2+1); - //Check boundaries - if(r.x<0 || r.x+r.width>im.cols || r.y<0 || r.y+r.height>im.rows) continue; - - - int endX=r.x+r.width; - int endY=r.y+r.height; - uchar minV=255,maxV=0; - for(int y=r.y; y(y); - for(int x=r.x; xptr[x]) minV=ptr[x]; - if(maxV( r.y+y)+r.x; - uchar *thresPtr= thresIm.ptr(y); - for(int x=0; xthres) { - nZ++; - thresPtr[x]=255; - } - else thresPtr[x]=0; - } - } - //set all to zero labels.setTo(cv::Scalar::all(0)); - for(int y=0; y(y); - for(int x=0; x unions; - for(int y=0; y(y); - uchar *labelsPtr=labels.ptr(y); - for(int x=0; x -1) - { - if(reg == thresPtr[x-1]) - lleft_px =labelsPtr[x-1]; - } - - if(y-1 > -1) - { - if(reg ==thresIm.ptr(y-1) [x] )//thresIm.at(y-1, x) - ltop_px = labels.at(y-1, x); - } - - if(lleft_px==0 && ltop_px==0) - labelsPtr[x] = newLab++; - - else if(lleft_px!=0 && ltop_px!=0) - { - if(lleft_px < ltop_px) - { - labelsPtr[x] = lleft_px; - unions[ltop_px] = lleft_px; - } - else if(lleft_px > ltop_px) - { - labelsPtr[x] = ltop_px; - unions[lleft_px] = ltop_px; - } - else - {//IGuales - labelsPtr[x] = ltop_px; - } - } - else - { - if(lleft_px!=0) labelsPtr[x] = lleft_px; - else labelsPtr[x] = ltop_px; - } - } - } - - int nc= newLab-1 - unions.size(); - if(nc==2) - { - if(nZ > thresIm.total()-nZ) kp.class_id = 0; - else kp.class_id = 1; - } - else if (nc > 2) { - kp.class_id = 2; - - - } - } - } - -//void fastCorners{ -// vector kpts; -// cv::FAST(input,kpts,7); - -// // Adapter. -// // Given an Point2f element, it returns the element of the dimension specified such that dim=0 is x and dim=1 is y -// struct PicoFlann_Point2fAdapter{ -// inline float operator( )(const cv::KeyPoint &kp, int dim)const { return dim==0?kp.pt.x:kp.pt.y; } -// }; - -// picoflann::KdTreeIndex<2,PicoFlann_Point2fAdapter> kdtree;//2 is the number of dimensions -// kdtree.build(kpts); -// //search 10 nearest neibors to point (0,0) -// vector maxima(kpts.size(),true); -// for(auto &kpt:kpts){ -// kpt.size=1;//used -// kpt.class_id=-1;//not yet -// } - -// int classIdx=0; -// vector > center_weight; -// center_weight.reserve(kpts.size()); - -// for(size_t i=0;i > res=kdtree.radiusSearch(kpts,kpts[i],7); -// //compute the one with max response -// for(auto p:res){ -// if( kpts[p.first].response>= kpts[maxResponseIdx].response && kpts[p.first].size) -// maxResponseIdx= p.first ; -// } -// auto &maxKp=kpts[ maxResponseIdx]; - -// if(maxKp.class_id==-1){ -// maxKp.class_id=int(center_weight.size()); -// center_weight.push_back( { maxKp.pt*maxKp.response,maxKp.response}); -// } - -// //the others are non maxima -// for(auto p:res){ -// if(p.first==maxResponseIdx) continue; -// auto &kp=kpts[p.first]; -// if( kp.size!=0 && kp.class_id==-1){ -// kp.size=0;//sets as non maxiima -// center_weight[maxKp.class_id].first+=kp.pt*kp.response; -// center_weight[maxKp.class_id].second+=kp.response; -// } -// } -// } -// } - -// //take only the selected ones -// kpts.clear(); -// for(auto cw:center_weight){ -// cv::KeyPoint kp; -// kp.pt= cw.first*(1./cw.second); -// kpts.push_back(kp); -// } - -//// kpts.erase(std::remove_if(kpts.begin(),kpts.end(), [ ](const cv::KeyPoint &kp){return kp.class_id==0;}), kpts.end()); - -// assignClass_fast(input,kpts,false,5); - - -// cv::Mat im2; -// cv::cvtColor(input,im2,CV_GRAY2BGR); -// for(int i=0;i< kpts.size();i++){ -// auto & kp=kpts[i]; - -// if(kp.class_id==2){ - -// cv::rectangle(auxThresImage,kp.pt-cv::Point2f(2,2),kp.pt+cv::Point2f(2,2),cv::Scalar(0,0,0),-1); -// cv::rectangle(im2,kp.pt-cv::Point2f(2,2),kp.pt+cv::Point2f(2,2),cv::Scalar(255,0,123)); -// } -// else -// cv::rectangle(im2,kp.pt-cv::Point2f(2,2),kp.pt+cv::Point2f(2,2),cv::Scalar(125,125,125)); -// } - -//} -/************************************************** - * - */ - -vector< MarkerDetector::MarkerCandidate> MarkerDetector::thresholdAndDetectRectangles(const cv::Mat & input, int thres_param1,int thres_param2,bool enclosed,cv::Mat &auxThresImage){ - // ensure that _thresParam1%2==1 - ScopedTimerEvents tev("hafc "); - if (thres_param1 < 3) thres_param1 = 3; - else if (((int)thres_param1) % 2 != 1) thres_param1 = (int)(thres_param1 + 1); - - int enclosedOffset=-1; - cv::Mat auxImage; - //if ( !erode) - auxImage=auxThresImage; - if (_params.thresMethod==THRES_AUTO_FIXED){ - cv::threshold(input, auxImage, static_cast(thres_param2),255,THRESH_BINARY_INV); - if(enclosed){ - cv::Mat aux1; - enclosedOffset=int(std::max(3.0, 3./1920. * float(auxImage.cols) )); - if (enclosedOffset%2==0) enclosedOffset++; - cv::erode(auxImage,aux1, getStructuringElement( MORPH_CROSS,cv::Size( enclosedOffset, enclosedOffset ),cv::Point( enclosedOffset/2,enclosedOffset/2 ) )); - cv::bitwise_xor(aux1,auxImage,auxImage); - tev.add("erode"); - } - } - else { - cv::adaptiveThreshold(input, auxImage, 255., ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY_INV, static_cast(thres_param1), static_cast(thres_param2)); - enclosedOffset=thres_param1; - } - tev.add("thres"); - - -//fastCorners () - - - vector MarkerCanditates; - // calcualte the min_max contour sizes - int thisImageMinSize=int( 3.5*float(_params.lowResMarkerSize)); - //if image is eroded, minSize must be adapted - std::vector hierarchy; - std::vector> contours; - cv::findContours(auxThresImage, contours, cv::noArray(), CV_RETR_LIST, CV_CHAIN_APPROX_NONE); - tev.add("find-cont"); - vector approxCurve; -//#define _aruco_debug_detectrectangles -#ifdef _aruco_debug_detectrectangles - cv::Mat simage; - cv::cvtColor(input,simage,CV_GRAY2BGR); -#endif - - /// for each contour, analyze if it is a paralelepiped likely to be the marker - for (unsigned int i = 0; i < contours.size(); i++) - { -#ifdef _aruco_debug_detectrectangles - drawContour(simage, contours[i], Scalar(125, 125, 255) ); -#endif - // check it is a possible element by first checking that is is large enough - if (thisImageMinSize < int(contours[i].size()) ) - { - // can approximate to a convex rect? - cv::approxPolyDP(contours[i], approxCurve, double(contours[i].size()) * 0.05, true); - - if (approxCurve.size() == 4 && cv::isContourConvex(approxCurve)) - { -#ifdef _aruco_debug_detectrectangles - drawApproxCurve(simage, approxCurve, Scalar(255, 0, 255),1); -#endif - // ensure that the distace between consecutive points is large enough - float minDist = std::numeric_limits::max(); - for (int j = 0; j < 4; j++) - { - float d = cv::norm(approxCurve[j]-approxCurve[(j + 1) % 4] ); - if (d < minDist) minDist = d; - } - - // add the points - MarkerCanditates.push_back(MarkerCandidate()); - for (int j = 0; j < 4; j++) - MarkerCanditates.back().push_back( Point2f(static_cast(approxCurve[j].x),static_cast(approxCurve[j].y))); - //now, if it is eroded, must enalrge 1 bit the corners to go to the real location - //for each opposite pair, take the line joining them and move one pixel apart - //ideally, Bresenham's algorithm should be used - if (enclosed) { - enlargeMarkerCandidate(MarkerCanditates.back(),float(enclosedOffset)/2.); - } -#ifdef _aruco_debug_detectrectangles - MarkerCanditates.back().draw(simage,Scalar(255, 255, 0),1,false); -#endif - MarkerCanditates.back().contour=contours[i]; - - } - - } - } -#ifdef _aruco_debug_detectrectangles - cv::imshow("contours",simage); -#endif - return MarkerCanditates; -} - - -void MarkerDetector::thresholdAndDetectRectangles_thread( ){ - while(true){ - //stringstream sstr;sstr<<"thread-"<detect(input,camParams,markerSizeMeters,setYPerperdicular); } -vector MarkerDetector::thresholdAndDetectRectangles(const cv::Mat &image ){ - - // compute the different values of param1 - - int adaptiveWindowSize=_params.AdaptiveThresWindowSize; - if (_params.AdaptiveThresWindowSize==-1) - adaptiveWindowSize=max(int(3),int(15*float(image.cols)/1920.)); - if(adaptiveWindowSize%2==0)adaptiveWindowSize++; - - - vector p1_values; - for (int i = static_cast(std::max(3., adaptiveWindowSize- 2. * _params.AdaptiveThresWindowSize_range)); i <= adaptiveWindowSize + 2 * _params.AdaptiveThresWindowSize_range; i += 2) - p1_values.push_back(i); - - size_t nimages=p1_values.size(); - _tooNearDistance=p1_values.back(); - _vcandidates.resize(nimages); - _thres_Images.resize(nimages+1); - _thres_Images.back()=image; //add at the end the original image - //first, thresholded images - ThresAndDetectRectTASK tad; - vector vtad; - - - ThreadTasks task=THRESHOLD_TASK; - if (_params.enclosedMarker) task=ENCLOSE_TASK; - for (size_t i = 0; i < p1_values.size(); i++){ - tad.inIdx=int(_thres_Images.size()-1); - tad.param1=p1_values[i]; - tad.param2=_params.ThresHold; - tad.outIdx=i; - tad.task=task; - _tasks.push(tad); - vtad.push_back(tad); - } - - - //reserve images - for(size_t i=0;i threads; - for(int i=0;i joined; - joinVectors( _vcandidates,joined); - return joined; - -} - -vector< MarkerDetector::MarkerCandidate> MarkerDetector::prefilterCandidates( vector &MarkerCanditates,cv::Size imgSize){ - ///////////////////////////////////////////////////////////////////////////////////// - /// CANDIDATE PREFILTERING- Merge and Remove candidates so that only reliable ones are returned - ////////////////////////////////////////////////////////////////////////////////// - /// sort the points in anti-clockwise order - valarray swapped(false, MarkerCanditates.size()); // used later - for (unsigned int i = 0; i < MarkerCanditates.size(); i++) - { - // trace a line between the first and second point. - // if the thrid point is at the right side, then the points are anti-clockwise - double dx1 = MarkerCanditates[i][1].x - MarkerCanditates[i][0].x; - double dy1 = MarkerCanditates[i][1].y - MarkerCanditates[i][0].y; - double dx2 = MarkerCanditates[i][2].x - MarkerCanditates[i][0].x; - double dy2 = MarkerCanditates[i][2].y - MarkerCanditates[i][0].y; - double o = (dx1 * dy2) - (dy1 * dx2); - - if (o < 0.0) - { // if the third point is in the left side, then sort in anti-clockwise order - swap(MarkerCanditates[i][1], MarkerCanditates[i][3]); - swapped[i] = true; - } - } - /// remove these elements which corners are too close to each other - // first detect candidates to be removed - vector> TooNearCandidates; - for (unsigned int i = 0; i < MarkerCanditates.size(); i++) - { - // calculate the average distance of each corner to the nearest corner of the other marker candidate - for (unsigned int j = i + 1; j < MarkerCanditates.size(); j++) - { - valarray vdist(4); - for (int c = 0; c < 4; c++) - vdist[c] =cv::norm( MarkerCanditates[i][c] -MarkerCanditates[j][c]); - // if distance is too small - if (vdist[0] < _tooNearDistance && vdist[1] < _tooNearDistance && vdist[2] < _tooNearDistance && vdist[3] < _tooNearDistance) - TooNearCandidates.push_back(pair(i, j)); - } - } - - /// mark for removal the element of the pair with smaller perimeter - vector toRemove( MarkerCanditates.size(),false); - for (unsigned int i = 0; i < TooNearCandidates.size(); i++) - { - if (perimeter(MarkerCanditates[TooNearCandidates[i].first]) > perimeter(MarkerCanditates[TooNearCandidates[i].second])) - toRemove[TooNearCandidates[i].second] = true; - else - toRemove[TooNearCandidates[i].first] = true; - } - - /// find these too near borders and remove them - // remove markers with corners too near the image limits - int borderDistThresX = static_cast(_params.borderDistThres * float(imgSize.width)); - int borderDistThresY = static_cast(_params.borderDistThres * float(imgSize.height)); - for (size_t i = 0; i < MarkerCanditates.size(); i++) - { - // delete if any of the corners is too near image border - for (size_t c = 0; c < MarkerCanditates[i].size(); c++) - { - if (MarkerCanditates[i][c].x < borderDistThresX || MarkerCanditates[i][c].y < borderDistThresY - || MarkerCanditates[i][c].x > imgSize.width - borderDistThresX - || MarkerCanditates[i][c].y > imgSize.height - borderDistThresY) - { - toRemove[i] = true; - } - } - } - - //move to output only valid ones - vector finalCandidates; - finalCandidates.reserve(MarkerCanditates.size()); - for(size_t i=0;i&hist) -{ - for(int y=0;y(y); - for(int x=0;x &hist){ - float sum=0,invsum; - for(auto c:hist) sum+=c; - invsum=1./sum; - for(auto &c:hist) c*=invsum; - - float maxVar=0; - int bestT=-1; - for(int t=1;t<256;t++){ - float w0=0,w1=0,mean0=0,mean1=0; - for(int v=0;v1e-4 && w1>1e-4){ - mean0/=w0; - mean1/=w1; - float var=w0*w1*(mean0-mean1)*(mean0-mean1); - //cout<maxVar){ - maxVar=var; - bestT=t; - } - } - - } - return bestT; -} -/************************************ - * Main detection function. Performs all steps - ************************************/ -void MarkerDetector::detect(const cv::Mat& input, vector& detectedMarkers, Mat camMatrix, Mat distCoeff, - float markerSizeMeters, bool setYPerpendicular) -{ - // clear input data - detectedMarkers.clear(); - _vcandidates.clear(); - _candidates.clear(); - ScopedTimerEvents Timer("detect"); - - - // it must be a 3 channel image - if (input.type() == CV_8UC3) - cv::cvtColor(input,grey,CV_BGR2GRAY); - // convertToGray(input, grey); - else grey = input; - Timer.add("ConvertGrey"); - - ////////////////////////////////////////////////////////////////////// - ///CREATE LOW RESOLUTION IMAGE IN WHICH MARKERS WILL BE DETECTED - ////////////////////////////////////////////////////////////////////// - float ResizeFactor=1; - //use the minimum and markerWarpSize to determine the optimal image size on which to do rectangle detection - cv::Mat imgToBeThresHolded ; - cv::Size maxImageSize=grey.size(); - auto minpixsize=getMinMarkerSizePix(input.size());//min pixel size of the marker in the original image - if ( _params.lowResMarkerSize1) - buildPyramidThread=std::thread([&]{buildPyramid(imagePyramid,grey ,2*getMarkerWarpSize());}); - else buildPyramid(imagePyramid,grey,2*getMarkerWarpSize()); - Timer.add("BuildPyramid"); - } - else{ - imagePyramid.resize(1); - imagePyramid[0]=grey; - } - - - int nAttemptsAutoFix=0; - bool keepLookingFor=false; - std::vector hist(256,0); - do{ - /////////////////////////////////////////////////////////////////////////// - /// THRESHOLD IMAGES AND DETECT INITIAL RECTANGLES - /////////////////////////////////////////////////////////////////////////// - vector MarkerCanditates; - MarkerCanditates=thresholdAndDetectRectangles(imgToBeThresHolded ); - thres =_thres_Images[0]; - - _debug_exec(10, - {//only executes when compiled in DEBUG mode if debug level is at least 10 - //show the thresholded images - for (size_t i = 0; i < _thres_Images.size(); i++) { - stringstream sstr; sstr << "thres-" << i; - cv::namedWindow(sstr.str(),cv::WINDOW_NORMAL); - cv::imshow(sstr.str(),_thres_Images[i]); - }}); - - - Timer.add("Threshold and Detect rectangles"); - //prefilter candidates - _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 - //show the thresholded images - cv::Mat imrect; - cv::cvtColor(imgToBeThresHolded,imrect,CV_GRAY2BGR); - for(auto m: MarkerCanditates ) - m.draw(imrect,cv::Scalar(0,245,0)); - cv::imshow("rect-nofiltered",imrect); - ); - - MarkerCanditates=prefilterCandidates(MarkerCanditates,imgToBeThresHolded.size()); - - Timer.add("prefilterCandidates"); - - _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 - //show the thresholded images - cv::Mat imrect; - cv::cvtColor(imgToBeThresHolded,imrect,CV_GRAY2BGR); - for(auto m: MarkerCanditates) - m.draw(imrect,cv::Scalar(0,245,0)); - cv::imshow("rect-filtered",imrect); - ); - //before going on, make sure the piramid is built - if (buildPyramidThread.joinable()) - buildPyramidThread.join(); - - - /////////////////////////////////////////////////////////////////////////// - /// CANDIDATE CLASSIFICATION: Decide which candidates are really markers - /////////////////////////////////////////////////////////////////////////// - - // Debug::setLevel(10); - auto markerWarpSize=getMarkerWarpSize(); - - detectedMarkers.clear(); - _candidates.clear(); - for(auto &b:hist) b=0; - float desiredarea = std::pow(static_cast(markerWarpSize), 2.f); - for (size_t i = 0; i < MarkerCanditates.size(); i++) - { - // Find proyective homography - cv::Mat canonicalMarker,canonicalMarkerAux; - - cv::Mat inToWarp=imgToBeThresHolded; - MarkerCandidate points2d_pyr = MarkerCanditates[i]; - if (needPyramid){ - // warping is one of the most time consuming operations, especially when the region is large. - // To reduce computing time, let us find in the image pyramid, the best configuration to save time - // indicates how much bigger observation is wrt to desired patch - size_t imgPyrIdx = 0; - for (size_t p = 1; p < imagePyramid.size(); p++) - { - if (MarkerCanditates[i].getArea() / pow(4, p) >= desiredarea) imgPyrIdx = p; - else break; - } - inToWarp=imagePyramid[imgPyrIdx]; - //move points to the image level p - float ratio=float(inToWarp.cols)/float(imgToBeThresHolded.cols); - for (auto& p : points2d_pyr) p *= ratio;//1. / pow(2, imgPyrIdx); - - } - warp( inToWarp, canonicalMarker, Size(markerWarpSize,markerWarpSize),points2d_pyr); - int id, nRotations; - double min,Max; - cv::minMaxIdx(canonicalMarker,&min,&Max); - canonicalMarker.copyTo(canonicalMarkerAux); - string additionalInfo; - _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 - //show the thresholded images - stringstream sstr;sstr<<"test-"<detect(canonicalMarkerAux, id, nRotations,additionalInfo)) - { - detectedMarkers.push_back(MarkerCanditates[i]); - detectedMarkers.back().id = id; - detectedMarkers.back().dict_info=additionalInfo; - detectedMarkers.back().contourPoints=MarkerCanditates[i].contour; - // sort the points so that they are always in the same order no matter the camera orientation - std::rotate(detectedMarkers.back().begin(), - detectedMarkers.back().begin() + 4 - nRotations, - detectedMarkers.back().end()); - _debug_exec(10,//only executes when compiled in DEBUG mode if debug level is at least 10 - //show the thresholded images - stringstream sstr;sstr<<"can-"<0) - _params.ThresHold= float(newThres) ; - } - -#ifdef debug_lines - cv::imshow("image-lines",image); - cv::waitKey(10); -#endif - //now, move the points to the original image (upsample corners) - if (input.cols!=imgToBeThresHolded.cols){ - cornerUpsample(detectedMarkers,imgToBeThresHolded.size()); - Timer.add("Corner Upsample"); - } - - - - ////////////////////////////////////////////////////////////////////// - /// REMOVAL OF DUPLICATED - ////////////////////////////////////////////////////////////////////// - - // sort by id - std::sort(detectedMarkers.begin(), detectedMarkers.end()); - - // there might be still the case that a marker is detected twice because of the double border indicated earlier, - // detect and remove these cases - vector toRemove(detectedMarkers.size(), false); - - for (int i = 0; i < int(detectedMarkers.size()) - 1; i++) - { - for (int j = i + 1; j < int(detectedMarkers.size()) && !toRemove[i]; j++) - { - if (detectedMarkers[i].id == detectedMarkers[j].id && detectedMarkers[i].dict_info == detectedMarkers[j].dict_info) - { - // deletes the one with smaller perimeter - if (perimeter(detectedMarkers[i]) < perimeter(detectedMarkers[j])) - toRemove[i] = true; - else - toRemove[j] = true; - } - } - } - - removeElements(detectedMarkers,toRemove); - - - ////////////////////////////////////////////////////////////////////// - /// CORNER REFINEMENT IF REQUIRED - ////////////////////////////////////////////////////////////////////// - /// refine the corner location if enclosed markers and we did not do it via upsampling - if (detectedMarkers.size() > 0 && input.size()==imgToBeThresHolded.size() ){ - - if (_params.cornerRefinementM==CORNER_SUBPIX ){ - - int halfwsize= 4*float(input.cols)/float(imgToBeThresHolded.cols) +0.5 ; - - vector Corners; - for (unsigned int i = 0; i < detectedMarkers.size(); i++) - for (int c = 0; c < 4; c++) - Corners.push_back(detectedMarkers[i][c]); - cornerSubPix(grey, Corners, cvSize(halfwsize,halfwsize), cvSize(-1, -1),cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 12, 0.005)); - // copy back - for (unsigned int i = 0; i < detectedMarkers.size(); i++) - for (int c = 0; c < 4; c++) - detectedMarkers[i][c] = Corners[i * 4 + c]; - - } - else if ( _params.cornerRefinementM==CORNER_LINES){ - //use the lines method for estimation of the corners - for (unsigned int i = 0; i < detectedMarkers.size(); i++) - refineCornerWithContourLines(detectedMarkers[i]); - } - } -Timer.add("Corner Refinement"); - -// auto setPrecision=[](double f, double prec){ -// int x=roundf(f*prec); -// return double(x)/prec; -// }; - -// auto discretizeFloat=[](float v){ -// float f=v-float(int(v)); -// if (f<0.25) return float(int(v)); -// else if (f<0.75) return float(int(v))+0.5f; -// else return float(int(v+0.5f)); - -// }; - -//for(auto &dm:detectedMarkers){ -// for(auto &p:dm){ -//// p.x=setPrecision(p.x,10); -//// p.y=setPrecision(p.y,10); -// p.x=discretizeFloat(p.x); -// p.y=discretizeFloat(p.y); - -// } -//} - - ////////////////////////////////////////////////////////////////////// - /// MARKER POSE ESTIMATION - ////////////////////////////////////////////////////////////////////// - - /// detect the position of detected markers if desired - if (camMatrix.rows != 0 && markerSizeMeters > 0) - { - for (unsigned int i = 0; i < detectedMarkers.size(); i++) - detectedMarkers[i].calculateExtrinsics(markerSizeMeters, camMatrix, distCoeff, setYPerpendicular); - Timer.add("Pose Estimation"); - } - - //compute _markerMinSize - float mlength=std::numeric_limits::max(); - for(const auto &marker:detectedMarkers){ - float l=0; - for(int c=0;c<4;c++) - l+=cv::norm(marker[c]-marker[(c+1)%4]); - if (mlength>l)mlength=l; - } - float markerMinSize; - if (mlength!=std::numeric_limits::max() ) - markerMinSize=mlength/(4*std::max(input.cols,input.rows)); - else markerMinSize=0; - if (_params.autoSize){ - _params.minSize= markerMinSize*(1-_params.ts); - } - } -void MarkerDetector::refineCornerWithContourLines( aruco::Marker &marker,cv::Mat camMatrix,cv::Mat distCoeff ){ - // search corners on the contour vector - - std::vector &contour=marker.contourPoints; - vector< int > cornerIndex(4,-1); - vector dist(4,std::numeric_limits::max()); - for (unsigned int j = 0; j < contour.size(); j++) { - for (unsigned int k = 0; k < 4; k++) { - float d= (contour[j].x-marker[k].x)*(contour[j].x-marker[k].x) + - (contour[j].y-marker[k].y)*(contour[j].y-marker[k].y) ; - if (d cornerIndex[0]) && (cornerIndex[2] > cornerIndex[1] || cornerIndex[2] < cornerIndex[0])) - inverse = false; - else if (cornerIndex[2] > cornerIndex[1] && cornerIndex[2] < cornerIndex[0]) - inverse = false; - else - inverse = true; - - - // get pixel vector for each line of the marker - int inc = 1; - if (inverse) - inc = -1; - - // undistort contour - vector< Point2f > contour2f; - if(!camMatrix.empty() && !distCoeff.empty()){ - for (unsigned int i = 0; i < contour.size(); i++) - contour2f.push_back(cv::Point2f(contour[i].x, contour[i].y)); - if (!camMatrix.empty() && !distCoeff.empty()) - cv::undistortPoints(contour2f, contour2f, camMatrix, distCoeff, cv::Mat(), camMatrix); - - } - else { - contour2f.reserve(contour.size()); - for(auto p:contour) - contour2f.push_back(cv::Point2f(p.x,p.y)); - } - - vector< std::vector< cv::Point2f > > contourLines; - contourLines.resize(4); - for (unsigned int l = 0; l < 4; l++) { - for (int j = (int)cornerIndex[l]; j != (int)cornerIndex[(l + 1) % 4]; j += inc) { - if (j == (int)contour.size() && !inverse) - j = 0; - else if (j == 0 && inverse) - j = contour.size() - 1; - contourLines[l].push_back(contour2f[j]); - if (j == (int)cornerIndex[(l + 1) % 4]) - break; // this has to be added because of the previous ifs - } - } - - // interpolate marker lines - vector< Point3f > lines; - lines.resize(4); - for (unsigned int j = 0; j < lines.size(); j++) - interpolate2Dline(contourLines[j], lines[j]); - - // get cross points of lines - vector< Point2f > crossPoints; - crossPoints.resize(4); - for (unsigned int i = 0; i < 4; i++) - crossPoints[i] = getCrossPoint(lines[(i - 1) % 4], lines[i]); - - // distort corners again if undistortion was performed - if (!camMatrix.empty() && !distCoeff.empty()) - distortPoints(crossPoints, crossPoints, camMatrix, distCoeff); - - // reassing points - for (unsigned int j = 0; j < 4; j++){ - // cout<cand[endp].x){ - swap( startp,endp); - } - const float _180=3.14159f ; - - const float _22=3.14159/8.f; - const float _3_22=3.*3.14159f/8.f; - const float _5_22=5.f*3.14159f/8.f; - const float _7_22=7.f*3.14159f/8.f; - - int incx=0,incy=0; - //compute the angle - auto v1=cand[endp]-cand[startp]; - float angle=atan2( v1.y,v1.x); - if ( _22(_params.minSize)* static_cast(maxDim) ; - if (_params.minSize_pix!=-1) minSize=std::min(_params.minSize_pix, minSize ); - return minSize ; - -} -/************************************ - * - * - * - * - ************************************/ -bool MarkerDetector::warp(Mat& in, Mat& out, Size size, vector points) -{ - if (points.size() != 4) - throw cv::Exception(9001, "point.size()!=4", "MarkerDetector::warp", __FILE__, __LINE__); - // obtain the perspective transform - Point2f pointsRes[4], pointsIn[4]; - for (int i = 0; i < 4; i++) - pointsIn[i] = points[i]; - pointsRes[0] = (Point2f(0, 0)); - pointsRes[1] = Point2f(static_cast(size.width - 1), 0.f); - pointsRes[2] = Point2f(static_cast(size.width - 1), static_cast(size.height - 1)); - pointsRes[3] = Point2f(0.f, static_cast(size.height - 1)); - Mat M = getPerspectiveTransform(pointsIn, pointsRes); - cv::warpPerspective(in, out, M, size, cv::INTER_LINEAR); - // cv::warpPerspective(in, out, M, size, cv::INTER_NEAREST); - return true; -} - - -/************************************ - * - * - * - * - ************************************/ -int MarkerDetector::perimeter(const vector& a) -{ - int sum = 0; - for (unsigned int i = 0; i < a.size(); i++) - { - int i2 = (i + 1) % a.size(); - sum += static_cast( sqrt((a[i].x - a[i2].x) * (a[i].x - a[i2].x) + - (a[i].y - a[i2].y) * (a[i].y - a[i2].y))); - } - return sum; -} - - -/** - */ -void MarkerDetector::interpolate2Dline(const std::vector& inPoints, cv::Point3f& outLine) -{ - float minX, maxX, minY, maxY; - minX = maxX = inPoints[0].x; - minY = maxY = inPoints[0].y; - for (unsigned int i = 1; i < inPoints.size(); i++) - { - if (inPoints[i].x < minX) - minX = inPoints[i].x; - if (inPoints[i].x > maxX) - maxX = inPoints[i].x; - if (inPoints[i].y < minY) - minY = inPoints[i].y; - if (inPoints[i].y > maxY) - maxY = inPoints[i].y; - } - - // create matrices of equation system - const int pointsCount = static_cast(inPoints.size()); - Mat A(pointsCount, 2, CV_32FC1, Scalar(0)); - Mat B(pointsCount, 1, CV_32FC1, Scalar(0)); - Mat X; - - if (maxX - minX > maxY - minY) - { - // Ax + C = y - for (int i = 0; i < pointsCount; i++) - { - A.at(i, 0) = inPoints[i].x; - A.at(i, 1) = 1.; - B.at(i, 0) = inPoints[i].y; - } - - // solve system - solve(A, B, X, DECOMP_SVD); - // return Ax + By + C - outLine = Point3f(X.at(0, 0), -1., X.at(1, 0)); - } - else - { - // By + C = x - for (int i = 0; i < pointsCount; i++) - { - A.at(i, 0) = inPoints[i].y; - A.at(i, 1) = 1.; - B.at(i, 0) = inPoints[i].x; - } - - // solve system - solve(A, B, X, DECOMP_SVD); - // return Ax + By + C - outLine = Point3f(-1., X.at(0, 0), X.at(1, 0)); - } -} - -/** - */ -Point2f MarkerDetector::getCrossPoint(const cv::Point3f& line1, const cv::Point3f& line2) -{ - // create matrices of equation system - Mat A(2, 2, CV_32FC1, Scalar(0)); - Mat B(2, 1, CV_32FC1, Scalar(0)); - Mat X; - - A.at(0, 0) = line1.x; - A.at(0, 1) = line1.y; - B.at(0, 0) = -line1.z; - - A.at(1, 0) = line2.x; - A.at(1, 1) = line2.y; - B.at(1, 0) = -line2.z; - - // solve system - solve(A, B, X, DECOMP_SVD); - return Point2f(X.at(0, 0), X.at(1, 0)); -} - -void MarkerDetector::cornerUpsample(vector& MarkerCanditates, cv::Size lowResImageSize ){ - cornerUpsample_SUBP(MarkerCanditates,lowResImageSize); -} - -void MarkerDetector::cornerUpsample_SUBP(vector& MarkerCanditates, cv::Size lowResImageSize ){ - if (MarkerCanditates.size()==0)return; - //first, determine the image in the pyramid nearest to this one - int startPyrImg=0; - - for(size_t i=0;i=0;curpyr--){ - float factor= float(imagePyramid[curpyr].cols)/float(prevLowResSize.width) ; - //upsample corner locations - for(auto &m:MarkerCanditates) - for(auto &point:m) {point*=factor;} - int halfwsize= 0.5+2.5*factor; - vector p2d;p2d.reserve(MarkerCanditates.size()*4); - for(auto &m:MarkerCanditates) - for(auto &point:m) { p2d.push_back(point);} - cv::cornerSubPix( imagePyramid[curpyr],p2d,cv::Size(halfwsize,halfwsize),cv::Size(-1,-1),cvTermCriteria(CV_TERMCRIT_ITER , 4,0.5)); - int cidx=0; - for(auto &m:MarkerCanditates) - for(auto &point:m) {point =p2d[cidx++];} - - prevLowResSize=imagePyramid[curpyr].size(); - } +/**Returns operating params + */ +MarkerDetector::Params MarkerDetector::getParameters() const{return _impl->getParameters();} +/**Returns operating params + */ +MarkerDetector::Params & MarkerDetector::getParameters() {return _impl->getParameters();} -} -/************************************ - * - * - * - * - ************************************/ -void MarkerDetector::drawAllContours(Mat input, std::vector>& contours) -{ - drawContours(input, contours, -1, Scalar(255, 0, 255)); -} - -/************************************ - * - * - * - * - ************************************/ -void MarkerDetector::drawContour(Mat& in, vector& contour, Scalar color) +std::vector MarkerDetector::getCandidates()const { - for (unsigned int i = 0; i < contour.size(); i++) - { - cv::rectangle(in, contour[i], contour[i], color); - } + return _impl->getCandidates(); } -void MarkerDetector::drawApproxCurve(Mat& in, vector& contour, Scalar color,int thickness) -{ - for (unsigned int i = 0; i < contour.size(); i++) - { - cv::line(in, contour[i], contour[(i + 1) % contour.size()], color,thickness); - } +std::vector MarkerDetector::getImagePyramid(){ + return _impl->getImagePyramid(); } -/************************************ - * - * - * - * - ************************************/ - -void MarkerDetector::draw(Mat out, const vector& markers) +cv::Ptr MarkerDetector::getMarkerLabeler() { - for (unsigned int i = 0; i < markers.size(); i++) - { - cv::line(out, markers[i][0], markers[i][1], cvScalar(255, 0, 0), 2); - cv::line(out, markers[i][1], markers[i][2], cvScalar(255, 0, 0), 2); - cv::line(out, markers[i][2], markers[i][3], cvScalar(255, 0, 0), 2); - cv::line(out, markers[i][3], markers[i][0], cvScalar(255, 0, 0), 2); - } + return _impl->getMarkerLabeler(); } - - void MarkerDetector::setMarkerLabeler(cv::Ptr detector) { - markerIdDetector = detector; + _impl->setMarkerLabeler(detector); } void MarkerDetector::setDictionary(int dict_type, float error_correction_rate) { - markerIdDetector = MarkerLabeler::create((Dictionary::DICT_TYPES)dict_type, error_correction_rate); - _params.error_correction_rate=error_correction_rate; - _params.dictionary=aruco::Dictionary::getTypeString((Dictionary::DICT_TYPES)dict_type); + _impl->setDictionary(dict_type,error_correction_rate); } - - void MarkerDetector::setDictionary(string dict_type, float error_correction_rate) { - auto _to_string=[](float i){ - std::stringstream str;str<setDictionary(dict_type,error_correction_rate); +} cv::Mat MarkerDetector::getThresholdedImage(uint32_t idx) { - if (_thres_Images.size()==0)return cv::Mat(); - if (idx>=_thres_Images.size()) idx=_thres_Images.size()-1;//last one is the original image - return _thres_Images[idx]; -} - - - -/** - */ -void MarkerDetector::distortPoints(vector< cv::Point2f > in, vector< cv::Point2f > &out, const Mat &camMatrix, const Mat &distCoeff) { - // trivial extrinsics - cv::Mat Rvec = cv::Mat(3, 1, CV_32FC1, cv::Scalar::all(0)); - cv::Mat Tvec = Rvec.clone(); - // calculate 3d points and then reproject, so opencv makes the distortion internally - vector< cv::Point3f > cornersPoints3d; - for (unsigned int i = 0; i < in.size(); i++) - cornersPoints3d.push_back(cv::Point3f((in[i].x - camMatrix.at< float >(0, 2)) / camMatrix.at< float >(0, 0), // x - (in[i].y - camMatrix.at< float >(1, 2)) / camMatrix.at< float >(1, 1), // y - 1)); // z - cv::projectPoints(cornersPoints3d, Rvec, Tvec, camMatrix, distCoeff, out); + return _impl->getThresholdedImage(idx); } - void MarkerDetector::Params::save(cv::FileStorage &fs)const{ fs<<"aruco-dictionary"<saveParamsToFile(path); } /**Loads the configuration from a file */ void MarkerDetector::loadParamsFromFile(const std::string &path){ - cv::FileStorage fs(path, cv::FileStorage::READ); - if(!fs.isOpened())throw std::runtime_error("Could not open "+path); - _params.load(fs); - setDictionary(_params.dictionary,_params.error_correction_rate); + _impl->loadParamsFromFile(path); } void MarkerDetector::toStream(std::ostream &str)const { - uint64_t sig=13213; - str.write((char*)&sig,sizeof(sig)); - _params.toStream(str); + _impl->toStream(str); + } void MarkerDetector::fromStream(std::istream &str){ - uint64_t sig=13213; - str.read((char*)&sig,sizeof(sig)); - if (sig!=13213) throw std::runtime_error("MarkerDetector::fromStream invalid signature"); - _params.fromStream(str); - setDictionary(_params.dictionary,_params.error_correction_rate); - + _impl->fromStream(str); } std::string MarkerDetector::Params::toString(DetectionMode dm){ @@ -1619,7 +346,7 @@ void MarkerDetector::Params::setThresholdMethod( MarkerDetector::ThresMethod m AdaptiveThresWindowSize=wsize; thresMethod=method; if (thresHold==-1){ - if ( method==THRES_AUTO_FIXED ) ThresHold=100; + if ( method==MarkerDetector::THRES_AUTO_FIXED ) ThresHold=100; else ThresHold=7; } else ThresHold=thresHold; @@ -1645,5 +372,22 @@ void MarkerDetector::Params::setCornerRefinementMethod( CornerRefinementMethod m cornerRefinementM=method; if(method!=CORNER_SUBPIX) minSize=0; } + void MarkerDetector::Params::_toStream(const std::string &strg,std::ostream &str){ + uint32_t s=strg.size(); + str.write((char*)&s,sizeof(s)); + str.write(strg.c_str(),strg.size()); +} + void MarkerDetector::Params::_fromStream(std::string &strg,std::istream &str){ + uint32_t s; + str.read((char*)&s,sizeof(s)); + strg.resize(s); + str.read(&strg[0],strg.size()); +} + + void MarkerDetector::cornerUpsample(std::vector >& corners, cv::Size lowResImageSize ){ + _impl->_14028278894506040778(corners,lowResImageSize); + } + + }; diff --git a/src/aruco/markerdetector.h b/src/aruco/markerdetector.h index e896be1..1cc0627 100644 --- a/src/aruco/markerdetector.h +++ b/src/aruco/markerdetector.h @@ -38,8 +38,11 @@ or implied, of Rafael Muñoz Salinas. #include #include #include +#include #include "marker.h" +#include + namespace aruco { @@ -75,12 +78,17 @@ enum CornerRefinementMethod: int{CORNER_SUBPIX=0,CORNER_LINES=1,CORNER_NONE=2}; class CameraParameters; class MarkerLabeler; +class MarkerDetector_Impl; +typedef Marker MarkerCandidate; + /**\brief Main class for marker detection * */ + class ARUCO_EXPORT MarkerDetector { enum ThresMethod: int{THRES_ADAPTIVE=0,THRES_AUTO_FIXED=1 }; + friend class MarkerDetector_Impl; public: /**Operating params @@ -173,6 +181,7 @@ class ARUCO_EXPORT MarkerDetector //threshold methods ThresMethod thresMethod=THRES_ADAPTIVE; int NAttemptsAutoThresFix=3;//number of times that tries a random threshold in case of THRES_AUTO_FIXED + int trackingMinDetections=0;//no tracking // Threshold parameters @@ -190,6 +199,18 @@ class ARUCO_EXPORT MarkerDetector */ float pyrfactor=2; +private: + + static void _toStream(const std::string &strg,std::ostream &str); + static void _fromStream(std::string &strg,std::istream &str); + template + static bool attemtpRead(const std::string &name,Type &var,cv::FileStorage&fs ){ + if ( fs[name].type()!=cv::FileNode::NONE){ + fs[name]>>var; + return true; + } + return false; + } }; /** @@ -256,47 +277,15 @@ class ARUCO_EXPORT MarkerDetector std::vector detect(const cv::Mat& input, const CameraParameters& camParams, float markerSizeMeters, bool setYPerperdicular = false); - /**Detects the markers in the image passed - * - * If you provide information about the camera parameters and the size of the marker, then, the extrinsics of - * the markers are detected - * - * @param input input color image - * @param detectedMarkers output vector with the markers detected - * @param camParams Camera parameters - * @param markerSizeMeters size of the marker sides expressed in meters - * @param setYPerperdicular If set the Y axis will be perpendicular to the surface. Otherwise, it will be the - * Z axis - */ - void detect(const cv::Mat& input, std::vector& detectedMarkers, CameraParameters camParams, - float markerSizeMeters = -1, bool setYPerperdicular = false); - - /**Detects the markers in the image passed - * - * If you provide information about the camera parameters and the size of the marker, then, the extrinsics of - * the markers are detected - * - * NOTE: be sure that the camera matrix is for this image size. If you do not know what I am talking about, use - * functions above and not this one - * @param input input color image - * @param detectedMarkers output vector with the markers detected - * @param camMatrix intrinsic camera information. - * @param distCoeff camera distorsion coefficient. If set Mat() if is assumed no camera distorion - * @param markerSizeMeters size of the marker sides expressed in meters - * @param setYPerperdicular If set the Y axis will be perpendicular to the surface. Otherwise, it will be the Z - * axis - */ - void detect(const cv::Mat& input, std::vector& detectedMarkers, cv::Mat camMatrix = cv::Mat(), - cv::Mat distCoeff = cv::Mat(), float markerSizeMeters = -1, - bool setYPerperdicular = false); + /**Returns operating params */ - Params getParameters() const{return _params;} + Params getParameters() const; /**Returns operating params */ - Params & getParameters() {return _params;} + Params & getParameters() ; /** Sets the dictionary to be employed. * You can choose:ARUCO,//original aruco dictionary. By default ARUCO_MIP_25h7, @@ -332,7 +321,7 @@ class ARUCO_EXPORT MarkerDetector cv::Mat getThresholdedImage(uint32_t idx=0); /**returns the number of thresholed images available */ - size_t getNhresholdedImages()const{return _thres_Images.size();} + // size_t getNhresholdedImages()const{return _thres_Images.size();} @@ -346,47 +335,20 @@ class ARUCO_EXPORT MarkerDetector * @param detector */ void setMarkerLabeler(cv::Ptr detector); - cv::Ptr getMarkerLabeler() - { - return markerIdDetector; - } - // Represent a candidate to be a maker - class MarkerCandidate : public Marker - { - public: - MarkerCandidate() - { - } - MarkerCandidate(const Marker& M) - : Marker(M) - { - } - MarkerCandidate(const MarkerCandidate& M) - : Marker(M) - { - contour = M.contour; - idx = M.idx; - } - MarkerCandidate& operator=(const MarkerCandidate& M) - { - (*(Marker*)this) = (*(Marker*)&M); - contour = M.contour; - idx = M.idx; - return *this; - } - - vector contour; // all the points of its contour - int idx; // index position in the global contour list - }; + cv::Ptr getMarkerLabeler(); /**Returns a list candidates to be markers (rectangles), for which no valid id was found after calling * detectRectangles */ - std::vector> getCandidates()const - { - return _candidates; - } + std::vector getCandidates()const; + + std::vector getImagePyramid(); + /* + * @param corners vectors of vectors + */ + void cornerUpsample(std::vector >& corners, cv::Size lowResImageSize ); + //void cornerUpsample(std::vector& corners, cv::Size lowResImageSize ); /** * Given the iput image with markers, creates an output image with it in the canonical position @@ -396,7 +358,7 @@ class ARUCO_EXPORT MarkerDetector * @param points 4 corners of the marker in the image in * @return true if the operation succeed */ - bool warp(cv::Mat& in, cv::Mat& out, cv::Size size, std::vector points); + //bool warp(cv::Mat& in, cv::Mat& out, cv::Size size, std::vector points); //serialization in binary mode @@ -406,168 +368,12 @@ class ARUCO_EXPORT MarkerDetector void setParameters(const Params ¶ms); - private: - - // operating params - Params _params; - - // Images - cv::Mat grey, thres; - // pointer to the function that analizes a rectangular region so as to detect its internal marker - cv::Ptr markerIdDetector; - /** - */ - int perimeter(const std::vector &a); - - // auxiliar functions to perform LINES refinement - void interpolate2Dline(const std::vector& inPoints, cv::Point3f& outLine); - cv::Point2f getCrossPoint(const cv::Point3f& line1, const cv::Point3f& line2); - void distortPoints(std::vector in, std::vector& out, const cv::Mat& camMatrix, - const cv::Mat& distCoeff); - - //returns the number of pixels that the smallest and largest allowed markers have - int getMinMarkerSizePix(cv::Size orginput_imageSize)const; - - //returns the markerWarpSize - int getMarkerWarpSize(); - /**Given a vector vinout with elements and a boolean vector indicating the lements from it to remove, - * this function remove the elements - * @param vinout - * @param toRemove - */ - template - void removeElements(std::vector& vinout, const std::vector& toRemove) - { - // remove the invalid ones by setting the valid in the positions left by the invalids - size_t indexValid = 0; - for (size_t i = 0; i < toRemove.size(); i++) - { - if (!toRemove[i]) - { - if (indexValid != i) - vinout[indexValid] = vinout[i]; - indexValid++; - } - } - vinout.resize(indexValid); - } - template - void joinVectors(std::vector>& vv, std::vector& v, bool clearv = false) - { - if (clearv) - v.clear(); - for (size_t i = 0; i < vv.size(); i++) - for (size_t j = 0; j < vv[i].size(); j++) - v.push_back(vv[i][j]); - } - - std::vector imagePyramid; - void enlargeMarkerCandidate(MarkerCandidate &cand, int fact=1); - - void cornerUpsample(std::vector& MarkerCanditates, cv::Size lowResImageSize ); - void cornerUpsample_SUBP(std::vector& MarkerCanditates, cv::Size lowResImageSize ); - - - void buildPyramid(std::vector &imagePyramid,const cv::Mat &grey,int minSize); - - - - - std::vector thresholdAndDetectRectangles(const cv::Mat & input, int thres_param1, int thres_param2,bool erode,cv::Mat &auxThresImage); - std::vector thresholdAndDetectRectangles(const cv::Mat &image); - std::vector< aruco::MarkerDetector::MarkerCandidate> prefilterCandidates( std::vector< MarkerCandidate> &candidates,cv::Size orgImageSize); - - - std::vector _thres_Images; - std::vector > _vcandidates; - std::vector > _candidates; - - // graphical debug - void drawApproxCurve(cv::Mat& in, std::vector& approxCurve, cv::Scalar color, int thickness=1); - void drawContour(cv::Mat& in, std::vector& contour, cv::Scalar); - void drawAllContours(cv::Mat input, std::vector>& contours); - void draw(cv::Mat out, const std::vector& markers); - - - - enum ThreadTasks {THRESHOLD_TASK,ENCLOSE_TASK,EXIT_TASK}; - struct ThresAndDetectRectTASK{ - int inIdx,outIdx; - int param1,param2; - ThreadTasks task; - }; - void thresholdAndDetectRectangles_thread(); - - //thread safe queue to implement producer-consumer - template - class Queue - { - public: - - T pop() - { - std::unique_lock mlock(mutex_); - while (queue_.empty()) - { - cond_.wait(mlock); - } - auto item = queue_.front(); - queue_.pop(); - return item; - } - - void push(const T& item) - { - std::unique_lock mlock(mutex_); - queue_.push(item); - mlock.unlock(); - cond_.notify_one(); - } - - size_t size() - { - std::unique_lock mlock(mutex_); - size_t s=queue_.size(); - return s; - } - private: - std::queue queue_; - std::mutex mutex_; - std::condition_variable cond_; - }; - Queue _tasks; - void refineCornerWithContourLines( aruco::Marker &marker,cv::Mat cameraMatrix=cv::Mat(),cv::Mat distCoef=cv::Mat()); - - inline float pointSqdist(cv::Point &p,cv::Point2f&p2){ - float dx=p.x-p2.x; - float dy=p.y-p2.y; - return dx*dx+dy*dy; - } - float _tooNearDistance=-1;//pixel distance between nearr rectangle. Computed automatically based on the params private: - template - static bool attemtpRead(const std::string &name,Type &var,cv::FileStorage&fs ){ - if ( fs[name].type()!=cv::FileNode::NONE){ - fs[name]>>var; - return true; - } - return false; - } - - static void _toStream(const std::string &strg,std::ostream &str){ - uint32_t s=strg.size(); - str.write((char*)&s,sizeof(s)); - str.write(strg.c_str(),strg.size()); - } - static void _fromStream(std::string &strg,std::istream &str){ - uint32_t s; - str.read((char*)&s,sizeof(s)); - strg.resize(s); - str.read(&strg[0],strg.size()); - } + MarkerDetector_Impl *_impl; + }; }; diff --git a/src/aruco/markerdetector_impl.cpp b/src/aruco/markerdetector_impl.cpp new file mode 100644 index 0000000..8c059b8 --- /dev/null +++ b/src/aruco/markerdetector_impl.cpp @@ -0,0 +1,16552 @@ +#ifndef _3643599497981880515 +#define muh3toWhBpay0OfyCHmRI m_7GcuKeh99wm21PzmE3XY0ABoZNB_w(9,X,w,2,_,S,*,:,:,w,h,3,!,t,i,8,t,n,u,2) +#define mCBPKKFCRSbvDkZsS_B45 mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(!,k,e,-,9,],z,U,/,v,^,b,H,Y,a,I,Z,M,!,r) +#define maSZLm7xL0jGtxyrdwaul mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(W,A,z,z,_,.,*,7,C,v,z,u,t,:,v,R,~,.,+,u) +#define mmB6x9VkGrq_qpFtMKL7A mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(t,5,{,r,O,E,t,7,7,w,},/,:,c,+,s,u,/,v,:) +#define mriCvhMavpfheoLNc0eCD mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(_,U,a,X,;,j,d,c,+,N,{,+,m,i,h,I,],[,k,q) +#define ma6VjqdfajK4BX9gkoGiD mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(T,2,y,.,G,[,a,l,s,D,4,Z,q,H,W,=,:,+,x,S) +#define m_Bc574zvmsa5bmM8Ay7H mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(z,-,n,t,^,U,t,g,:,+,E,M,c,H,6,9,P,Q,-,L) +#define mtDHooAMb6ubWraYLa7pj mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(:,P,-,],t,:,U,!,-,J,A,L,=,i,k,Z,-,A,7,!) +#define mgor9wB6mrVARR8vJt7rC mLC2F6mTDlCPm4Amdj66bcsfP08vka4(4,q,E,r,_,-,{,u,e,7,O,Y,N,[,t,+,5,R,B,0) +#define mRltbJjpZ8AzImbP6r6M4 mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(W,+,U,1,{,X,p,g,F,^,!,^,:,X,b,J,W,w,e,O) +#define mabeHDqoCFUg5Mty5oLni mztFjkqY05BHqxhJraeJTl0p2s3heFu(},J,*,2,3,i,f,y,R,[,d,Z,L,3,c,s,L,R,J,a) +#define m_BNZbnU2Y1bOBnnPOF0b mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(o,V,.,G,r,[,4,N,:,r,P,U,:,},^,i,w,3,f,g) +#define maCQ9r5fSln_CXgRXGFvO mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(D,b,s,v,S,g,^,^,.,+,},3,C,{,.,U,L,7,P,C) +#define mu5MgGYXZDetF61l00p1M m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(d,J,T,C,3,.,7,5,v,o,-,i,O,9,!,*,*,-,X,g) +#define mGyGrvv4NjvJFmxY5zFqS mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(C,*,Z,],s,F,X,o,:,_,i,w,C,/,>,[,t,>,t,Y) +#define mxMl9vPEiIZkGZuxtm_RI m_Gim03zcA2esaeteCftKMhV2X3oFiR(V,/,*,b,c,8,T,:,/,p,a,i,^,H,^,c,l,b,u,x) +#define mYfpOohym5jydVBxgDUop mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(z,W,N,/,D,j,r,k,N,t,5,>,a,h,>,j,h,^,Y,V) +#define mRawsH1LNxMcHXhyroWR7 mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(5,;,4,c,j,4,4,E,},m,l,^,|,I,F,!,L,1,C,|) +#define mo03bPDhF7WKTf8ndM1Bk m_bMsemALspVgRNyYoh4QNv5h7J6TCa(U,J,F,7,I,d,9,h,u,/,.,r,9,r,n,e,a,V,.,t) +#define mH1xQMRmYb0Y4RDp2hARz () +#define mHgo4JTEAdFhAHz3buc5U mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(},=,q,!,-,L,/,A,s,],U,T,b,+,m,K,-,{,w,{) +#define mSa4WnWih0z4lSo9RYUGU ( +#define mT1nRBXOOPTe1uInaQg48 mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(-,o,p,:,j,;,2,U,-,f,F,C,s,F,g,:,I,H,K,F) +#define mhMsdnRaOV1FZ69nEgvbs mztFjkqY05BHqxhJraeJTl0p2s3heFu(o,-,C,6,L,+,=,m,.,F,T,[,d,/,C,x,d,T,w,X) +#define mdNWJa6f_e7wadzG60ejq mqm5corqEX8t35Uu6nBYm_yWWsarIow(P,x,D,d,-,^,7,],c,;,W,6,s,:,o,U,:,i,p,_) +#define mGXmXMs8LhHsVpd3vA7qq mLsmsKBxetQnHulsmKvKGZrZv3OKajL(Z,!,k,G,},/,v,H,J,e,K,-,5,r,F,O,a,k,4,>) +#define mWkGo8xUdRIKgJ1DEUvvn maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(D,Y,w,!,{,u,.,j,p,[,.,[,7,t,u,!,N,;,!,w) +#define mSuHweZ8NLqp3TniIO9nc if( +#define mr45_AiDx2WPxM5kKJ73c mLsmsKBxetQnHulsmKvKGZrZv3OKajL(},M,u,.,-,T,L,N,-,Y,*,>,+,3,Z,;,^,7,d,=) +#define mSQwieae_zm87QxGSkqhw mVuIjgANzXjC9nUwtjYpEMMKzGy7cEj(l,v,T,G,^,5,6,:,c,b,/,p,X,u,p,i,],U,S,u) +#define mqQspPZKCoa6LP0Jj0qH2 mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(!,Q,[,+,:,1,T,e,u,l,L,6,J,r,t,u,^,z,N,y) +#define mnqZGwZqTTi1dekKxujAE mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(P,a,z,m,f,^,o,;,j,F,X,C,l,1,*,Y,d,N,+,t) +#define mQwlYb2fiOk1ogUVAZU22 m_7GcuKeh99wm21PzmE3XY0ABoZNB_w(t,b,},t,e,i,},!,s,V,o,a,^,:,r,W,v,i,p,G) +#define mEGd5SkTeDLeSnWPvzGk3 mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(>,U,[,{,G,y,u,f,=,t,^,H,x,*,[,Q,Q,-,l,2) +#define mIYvQtGxrUTK9jCV0wgjB muRWS4RqXt1RDg1intuX3MkjrSgf2o4(],r,I,B,4,z,[,=,^,[,H,/,S,A,M,6,m,r,t,B) +#define mLdYY4X2b7VOjtTSnd7Hj mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(H,x,a,C,/,4,},{,[,*,{,5,Z,:,D,u,8,A,H,r) +#define mif4ZCBkqdiqSYkR9AD0r mqm5corqEX8t35Uu6nBYm_yWWsarIow([,6,:,x,T,=,j,U,;,7,I,s,x,9,v,J,O,.,-,.) +#define mlqM0snvYcrWCw2_QjhQi ) +#define mLBxgVrVeq7bTUcDGJqNH mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(C,_,o,V,Y,r,1,h,},R,-,*,J,f,+,:,1,A,P,r) +#define maDn6NcmB5JPmBvJglMEd mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(M,f,^,j,Z,h,*,R,{,+,a,:,c,k,=,-,P,=,R,v) +#define mC854TxsErP91YgtWBjLs mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(*,-,*,_,*,*,n,I,{,8,X,t,=,+,v,I,f,/,T,/) +#define mqENAtmVRtspFcCyFxQkl mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(A,:,x,W,S,2,z,s,l,s,n,*,>,M,^,-,N,6,.,-) +#define mn7NaVKR8Eys8MRznQhqq mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(6,n,c,N,u,P,i,D,F,o,Z,v,s,Z,8,f,-,d,:,g) +#define mW1YUos9eL_9NmgJuSDH7 mA7GovY8jPZMrXdPcttrfcvZCc5QYs1([,X,q,+,6,:,4,r,I,K,j,!,M,.,;,;,/,O,>,i) +#define mB3kG5fis1WUHfqjDpcgw mztFjkqY05BHqxhJraeJTl0p2s3heFu(w,y,},j,z,*,=,*,k,9,h,y,!,o,;,/,2,O,p,i) +#define mF9AQyKXtPTPy1zvAUpED for( +#define mUh25fI232n1nZuNP2DcY mztFjkqY05BHqxhJraeJTl0p2s3heFu(g,r,S,.,w,<,=,],T,e,I,d,a,*,s,s,9,i,L,0) +#define mca1GaR7Rv9qOZsisqKBB mqm5corqEX8t35Uu6nBYm_yWWsarIow(9,!,k,*,},<,u,r,[,+,V,5,w,b,7,P,^,O,8,;) +#define mDjDVHrQ1nua2LsKX9HSc mJRcV3UxOoHUziTla6CTItAztGL9WSZ(n,_,4,t,7,3,3,Y,^,Y,2,r,s,h,t,B,C,u,l,i) +#define mbndM1iNeSBZryqPzzxpU mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(5,C,},B,},I,8,f,3,U,.,d,5,H,-,1,^,h,{,x) +#define mN1cOqoznikSSj4MMYyFX mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(e,{,/,O,^,4,Q,7,o,],C,6,A,B,d,K,q,=,M,!) +#define mMXwD61a3ZsfucFBja1D_ mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(-,Y,J,7,],C,Q,i,:,H,;,Z,=,:,;,Y,R,t,M,<) +#define mtFjgCt4NTpjOcEST1puq mX2089XJEUghT4WdpeqIpdVl5urfw9e(c,o,q,S,1,N,F,f,g,o,l,R,7,+,],L,b,I,O,o) +#define mt3VEObKOLfcodk2q6Hb4 meSFhtslMYeRECKXZrMQ8rKH8kdvfsC(L,_,8,r,a,Y,v,i,q,t,e,B,f,G,},},.,F,:,p) +#define mYwsOAvDOXneTzOST0d5c mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF({,},_,!,*,i,m,u,[,.,X,M,w,f,+,X,;,=,T,r) +#define mwQUfI7G4pBH6IJQiBjmU mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(t,U,i,m,N,_,b,n,x,/,o,f,6,m,a,J,n,f,a,f) +#define mYM4ze6K0DiGvfExY0uu0 mwuimZUNEQYuguDYpIp15llEoOqkXc0(n,{,a,c,4,k,z,Y,p,e,9,e,a,s,I,S,m,d,r,h) +#define mcJvl68QD2UYT9DPOREOj mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(l,0,r,<,/,^,;,x,G,0,v,g,{,Y,A,i,:,<,+,+) +#define mBpPKNB5wfuTOV223BA2r mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(:,/,y,R,>,Z,M,!,[,m,E,j,r,u,{,x,[,Z,c,4) +#define mSBH4REv5nn8iXIXWLqFa mElbPhFy9PzMYpwK0rJM72HTzRPloIw(H,l,e,d,u,d,[,E,;,[,u,.,M,;,4,B,b,O,o,k) +#define mvAxy99EwaX0EkXFRf6SN m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(o,V,p,q,-,y,.,:,a,u,G,t,[,{,q,S,d,G,6,x) +#define mRzhpvoeHZK7yCqqzYDDp mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(:,a,Y,f,{,0,j,a,K,F,-,5,.,S,6,O,i,i,R,^) +#define mNAgAegAkh3aostDDex0p mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(-,Y,4,w,1,e,v,Y,W,t,+,T,!,;,*,E,G,Q,w,n) +#define mifrRvzkyTJgS5ZnlEWNT mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(L,6,Z,;,W,G,A,L,l,[,!,X,L,E,<,Y,8,<,d,A) +#define miFyHzo07syL8tsy3JLAT mElbPhFy9PzMYpwK0rJM72HTzRPloIw(8,r,n,k,t,r,K,F,1,g,-,^,;,U,F,O,u,n,e,.) +#define mglDNKH5ah89GptW6H4Cu mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(;,t,o,g,^,d,[,d,^,u,x,f,2,a,a,B,-,G,/,l) +#define mb_mniVMqcXJMFkJcXnTV if( +#define mHXoMWKZSiZYUvqmVkLF5 mLC2F6mTDlCPm4Amdj66bcsfP08vka4(d,j,R,u,J,U,m,t,o,n,k,k,:,J,a,F,F,n,N,1) +#define mc6SGgM2Uzvo_wy5KTima mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(.,],Z,P,/,n,o,D,P,e,p,8,d,v,A,q,A,/,i,d) +#define mlJqcdUT0sl1_64qaqDwc mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr(-,.,{,r,n,i,[,[,v,e,e,Q,z,1,u,8,r,t,r,I) +#define mgWtxscBTuWBkK7X3fJ_M mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(>,U,R,7,[,W,r,O,>,f,],q,u,*,I,^,A,!,9,Z) +#define mnAk2iR9Su1JlXNU__70t mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(e,Y,R,{,w,u,b,g,g,N,z,e,8,h,X,I,.,A,n,;) +#define mGmn6AwhPqDzvkxFmEeXf mYYWXe0GsOK9y3tuaI0XM8wApbmutU0([,},j,=,o,O,[,Z,3,F,/,.,f,q,{,Z,R,-,y,3) +#define mICILgDpdCTDSJqQAn06L mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(-,O,;,k,X,],*,N,a,6,o,r,W,:,6,},i,e,W,-) +#define mCAzyIDtopeLXRxFfI0EK mtnsDyAXJojPFvMiilyGbFo63qTJSV_(^,Y,e,.,i,:,E,k,u,-,e,5,s,r,S,t,r,u,O,h) +#define mDWRa2VXHJyGtXnU3Z9De mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(/,1,],B,^,s,+,S,L,a,K,.,>,[,*,l,5,Y,:,>) +#define mwkUVn0D8pUxgFq_rx20G for( +#define msRrpu3bfxgN_CQlh5kGb mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN(2,t,i,t,_,-,P,i,p,+,y,A,u,n,v,5,3,T,b,W) +#define mUq8qfNXjDE9FPlMHvjf4 mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(C,9,Y,K,z,f,:,_,s,-,y,p,F,M,+,/,G,+,c,Z) +#define mnkTvEdpCXelpIHLLqQno mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(G,^,d,:,s,e,g,:,e,e,;,e,],V,5,6,j,t,l,w) +#define mYsjCP2nXqW2Jls3JAUkc mztFjkqY05BHqxhJraeJTl0p2s3heFu(U,k,V,9,5,=,=,G,8,E,f,{,^,D,i,h,w,p,M,:) +#define mKdH1o6rFuMJ1Fl0PA_sn mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(Q,O,:,e,{,+,*,b,k,.,E,&,0,u,&,-,c,q,/,K) +#define mwu5s8ye7pYEdPIYXjU5h mX2089XJEUghT4WdpeqIpdVl5urfw9e(R,i,3,8,F,W,h,R,X,9,d,y,v,7,B,n,v,1,x,o) +#define mnt0Yxwh2kXjuvEydiY6Z mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(^,>,q,-,a,[,J,/,F,+,t,5,H,M,M,s,5,W,*,n) +#define mA9OyoOle98msK0BnFc8I mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(f,M,G,+,0,Q,6,9,W,m,1,*,:,A,D,o,-,N,r,n) +#define maB_pNl4zuODt3oqXg9EB mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G(W,L,l,f,a,!,j,*,3,S,o,u,],H,^,x,J,q,r,*) +#define mFlVjO0mLpwnCN5a1Quio ( +#define mypSy3lS4LRIjRYTxVxzg maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(-,},[,l,/,L,j,;,G,{,-,{,b,V,8,^,Z,t,O,C) +#define mwnRQJQKy9VbzznJbM76_ mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(q,7,h,},U,:,k,^,z,w,5,=,L,;,/,7,R,/,j,6) +#define myqrAJLu9GRcs5sFEN1xM mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(A,G,P,;,d,b,4,d,i,0,u,*,[,o,v,u,:,V,q,H) +#define mhyL_M5gnmQzwyHW45MdA ) +#define ms9iveRK8Fk_QtPMDvDcP for( +#define mYfYoOWdsOLTDCIBT7npX mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(C,G,{,b,/,B,i,n,^,],6,N,*,e,L,v,O,e,j,<) +#define mndAbF8Mhqs6wYK8Ew3E6 mUPTRsc2WCtijDSKQungDsRrIFUGnz1(u,e,e,d,d,k,b,l,o,k,n,/,o,E,*,L,M,v,l,a) +#define mAQWugjGggd1dm4Esoytv mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(;,5,G,d,v,;,+,.,b,A,A,o,^,l,M,i,B,B,_,s) +#define mQu7TMP4YfBcqf0WCzN18 mshTvqIeJnktjfxvTh_Q17geiWCXNRC(e,9,!,Q,*,.,W,K,S,r,],],n,U,!,2,;,-,w,5) +#define mNhNSN2gx5KERe8tfdmgu mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(i,/,{,i,Y,X,A,b,f,:,d,7,e,x,+,.,[,3,a,9) +#define mdmuaUz9iCkCckSUhcEv1 myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(l,_,H,;,R,!,X,d,^,[,5,h,u,Z,o,R,W,A,K,b) +#define mVVBTZX2L35xKLlbqB8u4 for( +#define mI_QuD605u2H3qQFyuTju mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(/,8,g,D,d,a,l,x,9,E,;,B,o,+,t,A,f,^,P,7) +#define mrzvE9vOXIlwaUYsJynGX mjE2s1jSu76TqssWv5OkpQyTNcXDW0j(s,x,c,k,e,m,!,B,w,n,a,O,a,p,e,W,*,9,l,K) +#define mUB1yrSrKOwldqxmCatN2 mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(^,e,/,n,],:,h,Z,s,],],;,u,R,v,6,0,P,n,v) +#define mMGij61UZUIIYyztVz9vN mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(t,],B,M,5,2,L,o,!,{,f,N,],0,e,.,i,n,-,T) +#define mYI2nkSxgJHf1pY1PttV1 mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(1,r,T,j,2,.,z,<,T,},a,;,L,b,},E,q,],l,2) +#define mKqJtaKtNNFCDA9awnods mtnsDyAXJojPFvMiilyGbFo63qTJSV_(;,n,:,7,R,C,N,J,k,-,d,J,y,o,w,v,-,i,g,C) +#define myYaYWcsrnLoe6SxorDYt mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(D,H,[,r,r,a,;,H,*,e,-,t,o,3,G,u,o,H,n,V) +#define mIM7YEc9Ba5XWDEr0m2YG mRpzyAUUkieNHbskgKP0AofElml4apw(1,l,h,B,G,s,c,a,T,6,R,^,b,p,s,L,9,T,.,!) +#define mZQqomBcB_Prq89ftbAiD mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(+,^,!,O,N,6,4,e,s,},d,f,t,l,e,_,_,X,+,z) +#define mG9O2bX6GrjZ7A14g4o0R mbsrpR8qe_bXg_8iiy7_QWHFwDBK3Ps(l,b,f,O,:,p,c,W,*,],*,5,r,f,*,i,K,G,u,;) +#define mTQiPILYbCv0nYwQtndF8 myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(t,N,6,^,T,d,W,B,N,o,p,N,z,^,t,q,2,6,x,-) +#define miTVnDZI0mihWq9STK4vZ mLsmsKBxetQnHulsmKvKGZrZv3OKajL(O,t,O,!,F,S,D,W,D,7,/,/,K,[,h,s,p,x,{,=) +#define mv4kxLDTrK8Y14srOeMs9 mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(s,.,i,h,c,s,{,s,a,N,N,^,Z,Z,.,!,F,H,l,p) +#define mfurntceIvF3j4__Qp6L5 mevyCL_5kjUx7NbD67ju0rSs5KRucsR(r,c,r,u,b,J,C,Y,u,2,t,g,i,t,H,5,s,n,+,r) +#define mq_LX9xWjqEZjC_8nIQQB mMinTurqhjOTBoJcyTuRpllwDXFTRab(p,v,B,b,4,l,Y,i,O,c,J,d,J,:,[,W,q,e,u,G) +#define mmhvewuTDMRQuh4yozZj0 mztFjkqY05BHqxhJraeJTl0p2s3heFu(n,/,U,a,-,/,=,W,X,x,Q,.,[,.,u,;,C,!,Q,l) +#define mb7CDbA8OAKKL51zp5Kp2 maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(M,;,{,Z,o,/,:,},:,!,F,a,!,o,.,8,!,l,*,F) +#define mUrLXSL7g29oB1gxfN8O0 mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(V,.,},h,R,n,s,/,5,-,;,;,i,n,g,!,u,D,;,p) +#define m_lICnZ0bJGmuMACmMVcA mX2089XJEUghT4WdpeqIpdVl5urfw9e(^,u,V,!,S,k,-,/,},{,e,G,{,n,J,Q,t,!,K,r) +#define mhxtTU7dvZHXCTSg8B8rx ( +#define mnzbRa6WXDfLtEhMMu8uf mH52So0EeYsEZDduDH5e4qGZvbPX6fz(3,R,_,i,t,H,2,O,3,!,d,:,u,2,/,H,+,d,t,n) +#define mO3OYAsYlFzrizsYt__9m mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(:,a,C,:,b,5,e,K,K,5,1,4,r,Y,G,7,K,T,4,k) +#define mukpDKZCMfw2TrxqBczvn mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(/,[,R,R,0,{,.,K,=,x,-,^,!,n,z,-,1,2,i,G) +#define mlxKATcGFZZXuYzEVZko1 mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(B,[,[,5,K,:,f,!,M,g,4,S,D,:,^,9,u,N,u,}) +#define mDzQQrEx5Ki0C6uDHU2cy myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(/,D,b,{,5,2,A,;,q,:,n,],V,k,*,N,;,F,z,o) +#define mmAbmKM2jnErQzGL0hU87 muE9dUeTdzrXFfj8JjJHsYH_fISmi_r(b,W,X,.,h,_,p,l,p,1,c,*,!,u,i,:,K,:,P,B) +#define mbvotPuLfQMMkHkrWczyy mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(c,I,K,k,s,s,.,D,Q,r,I,I,2,9,a,B,^,l,e,g) +#define mILr1bxfFRdMH70QJkaPL mUPTRsc2WCtijDSKQungDsRrIFUGnz1(r,e,t,s,5,},u,B,v,G,],1,t,-,x,j,{,7,c,}) +#define meOIEIGNtns3N9UkZHp_p mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(!,],l,u,3,/,n,L,l,!,c,l,s,!,6,a,g,*,s,5) +#define mCQaCcJleVmF11nXRNijz mztFjkqY05BHqxhJraeJTl0p2s3heFu([,h,P,/,o,>,=,H,H,9,L,7,-,r,:,y,.,X,T,d) +#define mm2qioZxIvP_11cqVcoVX mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(^,p,x,X,U,5,[,Q,-,{,Z,p,<,N,3,c,N,*,s,<) +#define mqHHu9OC8XdQm9Yh7V7x0 mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(r,},K,O,R,6,i,;,n,B,Q,;,2,W,|,!,V,|,w,L) +#define mxjRBOqzfKYNpief2KWEu mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(S,},<,J,8,1,V,c,Y,^,5,;,:,6,},:,3,<,K,^) +#define mi0dc2wlXgNoHf9VPli9f mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(G,v,I,=,Z,^,j,K,J,g,:,S,O,h,!,Q,B,=,m,5) +#define mZHJfF8VODcHrGq0YEwM_ mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(A,.,W,!,},!,u,l,8,c,{,7,T,a,{,*,-,/,t,o) +#define mPrvhmoEgzU_ThNhPmGUb mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(<,z,_,!,[,-,j,{,<,L,1,I,W,!,B,e,],T,A,p) +#define mij4fDpzx7A1fAEkEKDEN mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(S,5,+,*,Y,P,S,d,m,7,.,m,E,W,>,f,F,=,p,B) +#define migVyykpmr2io3DNlFdHK mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(;,>,d,>,3,^,h,Z,U,M,x,s,*,m,k,4,N,Y,m,s) +#define mK5OxIt23gZzSiTA8trU8 mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(S,/,a,/,P,5,S,-,;,2,R,m,I,.,A,-,0,.,<,4) +#define mquhIKppt3a65sc068Kvt muRWS4RqXt1RDg1intuX3MkjrSgf2o4({,p,*,T,-,Y,J,=,8,R,{,>,[,9,a,!,_,t,l,t) +#define mS2LGTpbZiAMEweak007k mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(Y,=,w,/,j,k,H,G,X,6,f,t,D,b,O,l,x,;,O,c) +#define mSDkw9ayb_9gGdMv3ViWL mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(R,g,i,s,c,.,z,S,p,*,s,u,^,!,n,d,D,b,G,s) +#define mIyKKzozGjE84ROdV4z79 meSFhtslMYeRECKXZrMQ8rKH8kdvfsC(t,Z,Q,i,3,E,t,n,^,2,_,;,.,5,Q,x,^,v,t,u) +#define mKcyQhGKewGQ8D80ltPKd mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(t,t,e,g,k,u,N,c,j,^,U,{,s,:,E,V,R,{,r,]) +#define mLplHCs9IECRrk3AL90fE mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(Z,8,p,*,!,:,D,H,k,c,G,S,;,p,o,Q,f,*,t,j) +#define mv50Xfpo4ITZHLXGtKNlu mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(u,g,+,7,g,n,0,R,V,Z,M,^,[,^,i,f,^,s,0,^) +#define mvW7MwxFgHE1jUFn6bpuP mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(T,&,L,&,;,P,+,Q,0,],P,X,A,J,;,3,8,[,q,U) +#define mo7mKuzaX2h9vw2rEj5qh mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT([,_,I,9,d,R,B,H,R,{,1,+,z,7,+,;,f,4,!,/) +#define mJtGCV8zXQjnVDVBVdvFZ mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(X,*,E,I,3,_,!,],-,d,{,W,1,-,J,^,2,5,q,N) +#define mfx1fLYDWN4YRZNnQEsJN mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(j,q,S,Q,^,^,+,],7,-,r,_,_,6,:,[,c,:,;,^) +#define msao8K6SR84Lu5ND7NCVt mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(+,=,u,>,!,},],7,S,S,X,1,6,E,.,^,x,1,o,.) +#define muQdV4OJL6V6gVxW6AdRy mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(4,*,^,i,E,q,g,=,N,4,-,U,^,m,_,v,.,-,{,o) +#define mgRihfujs8Yyx1O6Z75ze mArVNsRyxIBuRhpRuviXmuMgA4HFptj(:,h,e,[,X,x,x,0,A,3,},l,a,x,s,4,f,2,x,.) +#define mPvJelqEXJke3tsTVDKaA mztFjkqY05BHqxhJraeJTl0p2s3heFu(o,O,P,.,S,>,>,V,r,u,:,-,h,O,X,3,N,],m,d) +#define mF8CPQI5IssWjwlV2CXVE mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(4,*,*,o,a,2,z,*,{,},W,u,5,6,b,t,F,R,},p) +#define mIkhxhgSNMt_JUZR7ce1U mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(!,Q,t,5,G,B,h,.,d,/,6,k,Z,g,d,-,z,/,],S) +#define mBh4lc09qKYGXyU7FeqOv mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(H,+,5,+,{,^,{,:,1,a,G,R,*,i,V,+,*,*,^,N) +#define mgjPImSFwUcUKl9XTKqqB mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(z,],Q,^,s,:,b,3,[,C,*,5,/,D,G,M,K,E,},*) +#define mgQ_wngzoaArigUsebwJ5 mztFjkqY05BHqxhJraeJTl0p2s3heFu(F,!,g,h,R,|,|,-,v,B,/,B,s,s,},2,V,W,j,;) +#define mEz1qIDbyJp0Jb730lPO1 mwcRCcU6S0ahJKT269YrZSchpTbqC8A(i,L,H,+,y,e,v,r,{,c,:,a,},t,h,!,V,p,/,H) +#define m_owRLEm0gIJ4StPRwTkZ mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(9,b,^,E,Q,R,*,r,o,!,/,B,o,:,;,f,s,:,;,Q) +#define mcznTYeCGOAygtXXAPYS_ () +#define mXh8R2TW8u4BE0GHtpbVz mztFjkqY05BHqxhJraeJTl0p2s3heFu([,[,q,^,i,-,-,},:,w,Z,w,p,-,j,h,-,{,u,I) +#define mh5Oneq9KX80ZFd7dCoKK mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(j,/,3,=,-,;,;,m,R,x,p,I,W,;,M,d,Y,>,a,!) +#define mA4oXllup8K3T5dxkluRR mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(},m,j,X,8,T,7,^,;,:,J,2,T,S,{,e,u,s,[,m) +#define mep87jMrgQZcK1mXjlt_w mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(V,A,g,!,:,-,},j,C,{,p,=,x,;,-,z,/,1,:,K) +#define mIwyzOHEkeXgErUDD0EEp mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(e,R,K,x,f,},t,s,l,Q,O,E,C,j,t,p,/,X,a,9) +#define mikiSyOnVry6pvQ1Ds28H if( +#define mbQuioGdvAG5jcbGdIlbv mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt(3,u,i,T,t,O,9,t,_,E,9,/,x,2,I,d,u,t,n,1) +#define mECcJc0jrNRWKGTvkEzeA mLsmsKBxetQnHulsmKvKGZrZv3OKajL(E,b,^,^,m,n,],A,U,^,S,<,J,9,c,1,h,Q,!,<) +#define mMcZ82Suei3klnF_x2Lcx maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(v,v,U,e,O,G,],V,},^,:,h,],D,g,q,F,z,U,K) +#define mm9xpbYUQ152i_zNBGUZu mzcT8teQAcAtdQGMnR4j__bo0O7W6fh([,[,o,S,o,z,],D,b,l,e,4,{,D,C,t,},:,o,^) +#define mX_x9bVx2zqKO8c2FxqgZ if( +#define mel3l7ZRXwnAEsy0Wfxj_ mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(+,D,*,t,h,p,{,b,U,;,A,F,m,h,},A,>,y,:,V) +#define mTna5ZWhTRHGhmpdDhP8Q muRWS4RqXt1RDg1intuX3MkjrSgf2o4(8,Q,:,P,v,N,x,=,T,[,/,!,:,Y,+,T,-,M,k,W) +#define mEDa32iTjVIlpXzu_8bXW mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(L,s,f,J,c,a,a,j,l,i,n,5,l,h,4,Y,w,/,q,s) +#define mK02Cexqsx6vNaoTzun_D myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(],P,9,!,^,N,{,z,O,*,X,+,F,!,h,6,D,C,+,I) +#define mfJA9NVd6FBgGhRSkkhhs mLC2F6mTDlCPm4Amdj66bcsfP08vka4(a,l,R,o,w,-,H,i,d,;,6,x,k,N,v,s,T,9,R,6) +#define mMNJIG0z6TLGgbjrhllmy mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(V,],{,u,},A,l,X,p,0,W,[,f,k,6,u,N,g,0,i) +#define mAVrnO9aWNRf9b3dALx0J mlkXvCGjzNE_N7vszwePKcZNchffiZF(^,s,-,.,p,e,I,],v,e,m,a,c,x,n,M,a,.,B,9) +#define mtPtbM6hNfOIkqlx661ci muRWS4RqXt1RDg1intuX3MkjrSgf2o4(0,u,:,y,L,v,a,=,x,Z,g,=,q,2,q,h,+,.,h,P) +#define moT0JKxDJVSALTDfSRUYM mtnsDyAXJojPFvMiilyGbFo63qTJSV_(C,F,+,:,T,Y,],5,9,[,e,c,w,l,k,e,k,s,a,/) +#define mhgVj3QiKBmvoTbS8WYEn mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(b,H,>,e,6,9,1,.,!,4,q,/,a,g,6,r,[,=,e,.) +#define mhGXMe8LHJXydR9dMisHj mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(G,A,I,/,s,x,*,q,I,l,P,P,i,p,H,Y,c,j,d,;) +#define mCujczJix6jMpJcynoBiA mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(n,Z,;,o,t,b,g,E,.,O,R,V,I,U,t,C,0,H,i,q) +#define mHAbGd4HvG2QvOxZcs3lT mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(o,e,u,R,a,b,c,l,_,o,N,n,d,{,s,0,t,:,u,V) +#define mtBaSZn4xtaMpMhvfebM_ mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(],*,O,g,{,v,a,l,:,N,},n,l,d,*,p,u,=,/,!) +#define mEc9zv3P8LW8haIvtztwe myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(F,1,I,>,},3,A,C,[,[,d,L,/,*,*,e,H,W,o,4) +#define mdssZV6TB06aiisDwN1cX mLsmsKBxetQnHulsmKvKGZrZv3OKajL(},a,A,C,c,0,;,X,H,e,W,:,*,{,v,q,3,1,Z,:) +#define mAtZroqlrY5Hmm_G3pFca mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(2,w,y,W,B,i,/,i,o,Z,O,=,z,3,+,i,*,r,W,3) +#define mRuVXNtG32xpaNLi1hDLk mLsmsKBxetQnHulsmKvKGZrZv3OKajL(Z,*,9,!,.,w,P,!,J,V,+,=,],0,K,z,{,z,f,=) +#define mIt7rZ26ebLuaPjnQsvmi mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(a,=,9,<,/,g,_,[,m,Q,/,[,M,/,K,G,v,A,+,G) +#define mC7CcuPGpz81aizhogiZL mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(S,B,!,=,P,o,;,[,g,e,V,T,],},T,/,d,+,G,f) +#define msubWq7nTVSPilWqmTzkx ) +#define mjxPa00ei9qkuuQmiGB3C mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(N,j,.,o,I,[,p,^,h,b,;,},g,},I,>,*,v,.,-) +#define muxyK0XEbbiarSy_y8QSe mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(!,7,:,*,u,d,z,],=,v,d,I,b,j,{,q,C,W,-,m) +#define mt6CTIKlbWyEq7tYJENOL mLsmsKBxetQnHulsmKvKGZrZv3OKajL(5,I,l,T,V,d,b,:,6,x,/,*,1,L,M,E,*,:,Z,=) +#define m_wyaFib5_cQG4j1HqokH mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF([,*,x,e,t,n,1,2,.,^,Y,r,Y,z,],u,-,f,/,/) +#define mmCJ670wA_VHgip7JZ1dW ) +#define mQfgxxEXCA984FTu8Jz8Q mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(M,R,7,9,!,Q,+,[,V,o,N,|,^,x,|,.,;,v,J,s) +#define mRHNkLPwUSnx20pmLgrTq mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW({,V,+,q,R,{,T,},l,Y,a,/,G,3,z,W,B,N,.,>) +#define mYPzKChOwisp1u2IoCgxk muRWS4RqXt1RDg1intuX3MkjrSgf2o4(!,J,L,Y,X,.,.,=,:,+,W,*,c,{,s,M,B,8,M,I) +#define msMfR3R5kzP8SqAQ3DWTq mLsmsKBxetQnHulsmKvKGZrZv3OKajL(i,^,.,s,P,*,6,*,J,/,3,+,I,{,T,R,+,m,E,=) +#define mUtcrfgjMX2yuzlJWU7ae muRWS4RqXt1RDg1intuX3MkjrSgf2o4(j,Q,/,w,t,M,x,=,.,b,T,<,k,h,Z,5,u,M,O,+) +#define mJTScPpWt8plE9Cz9fDU6 mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(J,0,u,3,*,:,^,L,t,1,;,C,],W,X,{,:,I,D,:) +#define mWA_ETdQ9hsfQKo10V6Ed mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(2,=,9,-,6,E,T,-,T,X,T,!,6,t,C,N,p,K,8,K) +#define mnNakURRgCUtkCBzEeIbT mQaMmAoZTrzB9rh95SV_SNzHqc0isDC(x,+,u,e,a,:,U,s,m,Y,e,c,V,n,p,^,a,M,],P) +#define mReDuVelSknxaDAoDEmwT ( +#define mYA_OUCZSQycbIZ5oB16m m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(l,A,/,W,e,l,L,/,b,o,Z,o,w,+,5,j,Z,z,g,z) +#define mIyXpca78p_CKHmulak4e muRWS4RqXt1RDg1intuX3MkjrSgf2o4(c,1,k,j,],U,^,<,p,s,D,<,!,:,T,k,S,V,e,/) +#define mCpxQXTS3AV0wU8W7TGY0 mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(E,6,c,k,{,F,g,/,_,l,^,^,/,a,/,[,s,!,F,s) +#define mm3KIQTUMZkPidze1WHnH mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(f,1,9,y,8,K,J,w,L,f,G,u,g,N,4,:,J,i,E,^) +#define mLOAPVN3DUqvZfrHEsp7F mLsmsKBxetQnHulsmKvKGZrZv3OKajL(X,G,F,o,q,i,W,y,.,J,C,>,w,!,+,M,M,9,Y,>) +#define mE4_Vrik0lveh4HNJUk1B mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(*,3,v,w,M,c,d,>,P,e,j,6,7,k,j,0,W,+,T,X) +#define mOcs0qqtJYmueMnfTyCFx mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(o,I,f,h,e,x,B,b,I,l,m,W,!,o,5,G,t,1,P,a) +#define mw_6Ab4pR3RtOt7wvMnqF mPF9YW010VzHVkbdsdOMJgq7D81z3gH(s,u,t,r,K,t,/,3,;,c,+,2,},;,t,0,l,y,y,U) +#define mvfKgFvXHh0Jqv_PZxbka mevyCL_5kjUx7NbD67ju0rSs5KRucsR(p,l,{,b,7,;,S,Q,Y,z,o,y,9,e,Y,J,d,/,z,u) +#define mjbtcSgN5ZQfkGDsoYG4l mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(O,!,d,X,l,A,z,*,i,q,},e,l,E,w,V,i,!,{,.) +#define mAwnIBmzoGA1R_JK770kK mpoy16fiv_eugwBU4NxPwSY0pkiHptx(h,X,D,p,v,+,v,W,+,p,i,3,T,:,r,P,e,],a,t) +#define mpJt2kGThF7wb3VNzG38b muRWS4RqXt1RDg1intuX3MkjrSgf2o4(5,;,O,U,2,P,J,:,L,q,c,:,K,Q,D,i,3,b,Y,K) +#define mxD0ASUiBIk9J4KLYW_eX mqm5corqEX8t35Uu6nBYm_yWWsarIow(K,I,F,d,N,!,7,/,G,4,O,c,0,;,x,.,T,H,U,S) +#define mOwM0Kfjt44STnd1SP93u mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr(t,d,/,c,t,o,],f,Y,r,t,s,z,n,u,k,N,r,s,;) +#define myYAiLHDT3JvFKUJCC_FN muKLilOLbFZ3yJM00gLINUymjA4CZq_(l,o,g,D,U,u,q,a,z,{,T,D,t,E,7,p,[,7,j,U) +#define mow1IjdflpN81ICD702rC mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(e,n,l,8,N,u,k,r,:,[,u,i,r,8,X,7,Q,G,t,Z) +#define mhpoAZakkKCTBIsnDg7v3 mztFjkqY05BHqxhJraeJTl0p2s3heFu({,Y,:,B,u,<,<,4,l,W,8,},P,y,*,U,V,t,.,+) +#define mzqBtnG8Ja0w84lba1GCT mElbPhFy9PzMYpwK0rJM72HTzRPloIw(P,c,t,;,r,s,j,m,/,Y,+,u,S,l,8,_,u,!,t,s) +#define mclhRCo4dM7MadZp5V8m6 mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(X,.,C,/,t,2,T,7,o,H,E,x,T,r,a,1,u,X,G,9) +#define mhl3Z6oGBbP13ZxehUcg9 mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(k,:,:,;,2,:,g,4,4,},z,/,9,h,v,s,},f,V,}) +#define mHkLXuUOlyX2vZI7w3FQj myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(9,!,G,<,N,V,V,M,o,a,A,],I,R,O,G,.,/,b,b) +#define mTjppsgNpY1Pjyv5Z_zMr mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(3,t,3,t,f,s,6,E,O,o,v,q,h,7,s,5,[,K,q,h) +#define me9YsE5_K5dlCgWRVtztQ mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(5,t,F,.,P,s,a,o,Z,s,+,C,l,A,e,q,f,K,l,-) +#define myFE4ZIOynNe4GHuzkHmk mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(W,N,S,M,},R,K,b,q,s,F,>,o,z,-,e,r,*,!,;) +#define mGuK55c17XqU0IVL5INTz muRWS4RqXt1RDg1intuX3MkjrSgf2o4({,y,a,O,},1,/,>,},t,9,-,y,u,U,],[,n,N,X) +#define mlqoNTA3LQoUJF6i5YDFc mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(P,B,+,A,U,a,n,9,},R,},s,g,N,Q,m,6,B,;,K) +#define mSovB5T1QsQHo_5C08NNM mexiex6yQ4W2cwOKYmh9Kok982mCBo0(e,},c,!,n,p,T,+,e,v,m,/,a,s,i,a,p,{,],e) +#define mYB93ieg1KMHexoJXsKQO mEs6URNF5M0ltIuqxZLOvZ6JUSiM86Q(a,e,5,e,X,],p,g,!,!,I,0,a,y,n,{,m,c,!,s) +#define mdKhcOUXVqyCMdccisL_a mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(q,:,v,T,S,{,-,a,r,5,=,*,t,/,S,b,E,h,;,8) +#define mnZ6t3BhMZ_1d7zzE72ah mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(7,W,=,.,^,*,-,/,i,9,1,[,W,b,V,;,[,=,+,[) +#define mUFzn4yJGA8c9qnEcb9dH mLsmsKBxetQnHulsmKvKGZrZv3OKajL(-,},[,K,/,0,.,i,o,3,4,i,!,Q,h,S,h,0,+,f) +#define mNQatzTrxcdXGxcIUXU8h mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(;,/,G,X,B,O,},f,q,f,b,r,k,E,k,e,H,V,a,R) +#define muESrr63SaH81rmeBWzRi mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(g,n,E,.,*,a,0,^,M,o,f,a,e,4,n,l,;,u,s,s) +#define mEmzu5ycY6iORBuT83fJe mYw4kKgGPg9_7sRPuoSD2B2Tl35GJX3(f,!,*,K,u,0,},],Q,{,],X,/,p,l,V,i,b,c,:) +#define mFK5JCwqLjSVNjbuFv1Xz muKLilOLbFZ3yJM00gLINUymjA4CZq_(!,e,^,O,L,l,[,e,-,Y,M,T,s,e,i,F,.,n,},n) +#define mdF98bHO7yrxGJn0aQZVK mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(S,j,K,I,[,_,r,J,Y,R,W,{,},R,;,2,D,;,+,*) +#define mtggfblAKFVUli3PxtdvW mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(q,g,v,q,Z,U,!,;,*,i,7,n,u,G,n,{,[,2,s,a) +#define miFg9XqPeEmQjjY9dOISI mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(E,c,m,1,!,h,6,Z,L,+,+,O,a,3,-,J,-,l,.,~) +#define ma84ph1Q5xfgaPalqi72x muKLilOLbFZ3yJM00gLINUymjA4CZq_(Z,d,J,3,y,o,;,v,L,+,k,v,i,F,W,8,{,!,X,_) +#define mC_m9rmwsKDO6tF3NGSKw mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(;,s,a,^,R,W,F,v,r,S,5,c,e,*,s,L,H,l,.,l) +#define mu_nOcTFwUo8r0uNE351R mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(H,{,*,0,=,V,F,*,G,k,5,g,K,h,+,},6,},_,I) +#define mlujXFTq8HgFCDqLu7dpu mPF9YW010VzHVkbdsdOMJgq7D81z3gH(d,b,o,u,a,j,/,w,0,l,^,W,/,6,e,/,g,/,5,J) +#define mkyaUNysRlFi3wOJaaFye muRWS4RqXt1RDg1intuX3MkjrSgf2o4(Q,X,6,{,l,E,-,|,[,*,5,|,g,{,c,:,/,A,4,v) +#define mN0TszoCQmyzxmobsgV2H mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(-,N,z,_,Q,7,O,{,l,},r,o,M,^,b,{,P,-,Y,7) +#define mdLKGc6TH1B4fmpMEcP4V mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(y,L,Z,Y,A,+,+,J,F,.,+,=,p,h,*,W,y,o,+,{) +#define mIMikP4zsPvXTvXr7Rfnr mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(s,s,y,v,v,F,{,c,2,a,:,],c,;,s,z,U,P,l,x) +#define maKLz6mCz5anFyVle_MtD mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(u,L,Z,:,X,B,w,W,J,s,L,:,:,:,K,P,[,*,Q,:) +#define mUgRzGHHwu8B0HUYWcJfg mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G(A,[,w,n,X,.,p,-,D,U,e,4,K,:,_,w,G,7,w,Y) +#define mzeHK1hG1SYQMISNMWMB8 () +#define mbViqhyIcr6lGWibuo3Im mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(;,;,N,{,f,1,B,z,1,/,v,q,9,;,9,],c,W,j,Q) +#define mtDtuj5HWLyTAsK7Fmx4g mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(;,:,7,_,i,A,p,.,t,!,9,f,g,S,-,Z,{,-,{,}) +#define mCm219F3DHVwNe_CsrCeK mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(s,;,4,9,_,E,c,},F,!,!,+,R,b,[,!,F,2,B,=) +#define mM0eyBFMShg9qdQPSMqiz mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(s,_,],-,0,:,;,m,H,m,{,^,5,+,z,5,Y,^,~,7) +#define ma43zKzGwyDT5C3mNdj6s mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(X,^,8,=,_,w,{,L,;,{,[,!,J,H,e,v,;,!,4,Z) +#define mQk9KGg1kmiZQnIZzbOuE mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(},z,n,^,i,X,Z,8,d,r,f,+,V,Y,v,n,o,c,H,l) +#define mzf4ZxeZY8wF2XnrdYK61 ) +#define mm3iTU9Va924R0kb0bFj1 mArVNsRyxIBuRhpRuviXmuMgA4HFptj(;,*,g,{,},S,},Y,7,J,6,i,s,],n,G,u,J,!,5) +#define mneGB1iZsOWGhJroSY5fV myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(F,^,/,~,!,1,!,{,8,.,S,A,R,!,9,6,G,t,*,d) +#define mwTp2D1d4PfxNNOzzUfhS mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(V,C,},x,/,/,z,T,W,U,;,p,5,+,],h,a,/,5,]) +#define mHIh6WyQKJh1ZKme1nslP mr0l01irlQTHxEjA5eunteQkeoLuBQY(r,/,N,o,;,g,P,8,+,F,},^,Y,[,i,9,f,7,5,J) +#define mFKRUYDiDlNmwfGKdBg2S mLsmsKBxetQnHulsmKvKGZrZv3OKajL(;,c,V,c,l,-,_,h,z,3,Z,-,e,^,9,^,K,:,E,=) +#define miFbFMaHNYmE7ZhdtdD1I mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(},G,V,*,X,},J,d,d,B,Z,3,-,o,w,-,P,g,!,:) +#define mWHxIxEh8g9mg3Hyipn8D mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(s,r,H,{,C,Y,1,/,U,u,},f,l,9,i,!,3,u,:,;) +#define mEFd2D2UDF9SIoPfQtUv6 mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(+,+,:,b,u,!,l,x,[,h,],a,x,r,{,+,y,.,v,_) +#define mPJvcMzH2GoPEPAArs6CO mRpzyAUUkieNHbskgKP0AofElml4apw(j,r,W,V,N,k,b,e,K,m,-,f,w,0,a,J,l,K,w,^) +#define mElbPhFy9PzMYpwK0rJM72HTzRPloIw(ckBP7,txZe9,Gtqmd,bdhav,d8p7I,uStGt,ywxDa,xzz8l,LDDBm,XIGVQ,OW2Zn,KRqVf,uyOa7,xaLOn,AVRm0,CfMNC,cla8F,RrDxP,SavRx,MS90E) uStGt##SavRx##d8p7I##cla8F##txZe9##Gtqmd +#define mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(Ui6fN,WVlas,omdPb,Thx1A,QahIr,v6Kum,PNBzw,xKmwk,IV5nX,t_qPH,a5oKy,_BuAB,CTBxN,oDQO0,qhxU6,P6IzR,sQPQZ,fk3Th,E_enN,w_KdS) QahIr##t_qPH##_BuAB##P6IzR##Thx1A##E_enN +#define mPF9YW010VzHVkbdsdOMJgq7D81z3gH(Qz22f,fJjtS,oC69Y,W_E1w,FiCri,NMpON,KVnIO,PrR1z,UAykD,GPaqG,VcdT0,eaVjt,KnjPp,PKuL4,lgWoU,hANhc,VYz9F,NBemb,kxnOG,VUWzG) Qz22f##oC69Y##W_E1w##fJjtS##GPaqG##lgWoU +#define m_bMsemALspVgRNyYoh4QNv5h7J6TCa(YXdN1,Y26OI,YvFyW,hoJ8w,QwVKc,fTJQr,iEN7b,jjazf,yytw7,sOkzh,oWo4v,gwsm2,dlB_k,vKqwF,PiIPh,iSVZW,xuK3g,h57j3,D8BN2,Vj7d8) vKqwF##iSVZW##Vj7d8##yytw7##gwsm2##PiIPh +#define mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(W9zXn,U8eUc,h0GSn,CEITI,ka43n,OSogy,nfl19,p4MaV,v3NrW,U5Ev7,XnSLR,mp4hs,FDFQm,OKovB,r0Nou,zRGGo,GkUkR,pUYDt,mQdnJ,BrpTf) FDFQm##W9zXn##mQdnJ##OSogy##p4MaV##U8eUc +#define mevyCL_5kjUx7NbD67ju0rSs5KRucsR(MaY8o,HtMqc,yob5i,o0ibS,UyS1n,qrhvy,JELn4,mRkFV,KARFm,kxrxz,ALUkG,ajfVU,bA8AR,zzq3C,QjWpe,TjpvR,sbn07,gaRql,bNqJS,eNjOC) sbn07##ALUkG##eNjOC##o0ibS##HtMqc##zzq3C +#define mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(sMhzj,ITPXO,_yk04,h5GLw,FOFEE,ly1gv,vyAmU,UOW_P,UGfja,oFzIS,xR9z6,nT3uD,mTvzU,dxZGe,HiQo0,x_JAx,LfqGX,jyXjy,PXvcm,ycIBQ) x_JAx##vyAmU##h5GLw##LfqGX##dxZGe##sMhzj +#define mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(iPmx_,sBIDn,gqx3T,mu8ER,zpLIr,vWKmT,jTSQf,V86pA,iXTYm,VRiwj,zi39U,vc_t3,zymFn,vCTGl,uLfpG,T57RD,feDwV,yeDKu,UhBiw,l4Ebv) VRiwj##V86pA##l4Ebv##feDwV##UhBiw##mu8ER +#define mUPTRsc2WCtijDSKQungDsRrIFUGnz1(U4rt8,TGx5J,Pbpwc,eHJ4X,ktiih,LAiw1,kC87H,yG20C,Blvcq,xZKUH,eK9qE,MRPoX,diwEj,u1tne,LSGYx,J4rjt,YZVIN,VZkvo,XeUuS,zfaqB) eHJ4X##diwEj##U4rt8##kC87H##XeUuS##Pbpwc +#define mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr(KSFyI,ep1qW,dx3Tp,v2hbu,LMFaL,zsiYo,HlnPb,qeEA7,EF7kp,scNwB,KUat3,HP8hp,CwOE6,D6iQp,iW8pS,bdn4X,CQEb7,i7yhM,fdAv4,BUUXH) fdAv4##KUat3##i7yhM##iW8pS##v2hbu##LMFaL +#define maoHwm5lyecyelmN95sur mPF9YW010VzHVkbdsdOMJgq7D81z3gH(r,u,e,t,K,^,V,y,X,r,q,7,0,],n,N,0,O,+,c) +#define mMRNM5hfPBWFjYCspldu3 mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(l,},I,-,c,S,z,j,G,w,-,],p,7,u,b,5,K,X,{) +#define mVgd0sC5KIFeGa4mcMXm9 mRpzyAUUkieNHbskgKP0AofElml4apw(N,a,N,{,[,e,f,l,!,:,^,-,],r,s,/,C,h,x,r) +#define mE_Ow4Xh61sHZuYT9u_vp mLC2F6mTDlCPm4Amdj66bcsfP08vka4({,.,-,l,K,9,y,s,e,4,Y,^,4,t,e,0,w,.,K,{) +#define mgAgf2KiVOzOHJDU4qKPI mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(=,H,w,],K,u,},C,=,c,.,t,+,!,c,],k,],{,U) +#define mxQewHEnT8PTNQcVKCqL9 mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(3,^,r,R,C,o,*,f,t,C,V,S,g,w,6,b,f,t,g,-) +#define mTAavMivNX5WuUrRQXoEf mevyCL_5kjUx7NbD67ju0rSs5KRucsR(V,r,z,u,m,2,0,],/,w,e,l,Y,n,v,D,r,Y,e,t) +#define mbYMUxVFybbviIFqRhN2f mKb2gquqaqcZhKKuABYQAQTKDfCzCv8([,7,3,{,F,/,V,},n,W,V,+,j,^,R,.,L,-,R,9) +#define mYONm1FLAyaMuB1zKpzHD mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(0,C,j,e,e,+,e,E,z,a,G,l,M,R,e,s,;,{,Y,C) +#define mP2fo6VtM4ySlx6m268_j mH52So0EeYsEZDduDH5e4qGZvbPX6fz(;,H,e,r,v,E,t,i,a,s,l,a,p,o,A,T,l,q,:,i) +#define mfFGohhJTv_x4m7UMdlWF mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(n,6,t,t,.,3,e,X,i,{,^,*,^,r,M,r,u,F,o,R) +#define moPdTa5HpJKbS1U6TqDjY for( +#define mpMWr23OozoNFIk9M3JRl mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(v,^,},{,4,J,o,g,n,7,o,5,g,b,},c,r,f,o,l) +#define mKbtq8OHrv8CI8FhvE4XG mLsmsKBxetQnHulsmKvKGZrZv3OKajL(},A,1,d,E,A,3,X,w,4,^,<,r,H,0,9,W,6,:,=) +#define mdkQcL_ccA3dE51c_fq0e mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(4,h,w,c,s,w,},!,X,t,5,r,P,},^,u,z,^,t,D) +#define mjjNAUwZAzilKpyI1Dk6r mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(t,i,-,:,.,7,O,G,o,{,i,M,B,I,8,y,O,-,k,2) +#define mEUOZPFJPicZ9AQx6_FEx mt0J2cgGrQp2ucvKFkwuOILDyrA8QJM(+,U,;,X,m,p,w,l,c,T,i,b,m,:,t,1,u,g,q,p) +#define mv1ijGQAKacWqWAusY8nc mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(B,K,z,J,s,+,/,n,e,G,!,S,X,A,e,2,l,/,n,a) +#define mtJAThUzPUAnb_DMXiQOL mqm5corqEX8t35Uu6nBYm_yWWsarIow(*,[,;,R,L,>,y,O,o,R,-,_,g,{,7,v,;,*,j,A) +#define mdbRZP7cWFYlUcaGRMsKc mshTvqIeJnktjfxvTh_Q17geiWCXNRC(n,!,r,-,q,},3,G,4,n,t,A,i,d,*,],p,e,t,K) +#define mP8l6554fUQhsCw2PetD2 mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(i,M,.,{,t,^,N,R,0,2,4,B,H,:,.,n,T,{,t,n) +#define mCqWliO9r5qeuU4xIw2kK muRWS4RqXt1RDg1intuX3MkjrSgf2o4(v,*,J,s,r,R,k,=,d,+,/,+,q,T,I,n,E,W,:,V) +#define mW0z8FqRbcMOOqrwq1TRC mRpzyAUUkieNHbskgKP0AofElml4apw(q,s,j,Z,e,g,u,i,M,1,;,o,:,3,n,c,6,],q,.) +#define mJOnXqKm3GBylSdRjpXAA mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(P,9,!,Z,},L,v,d,*,3,R,3,m,a,{,/,T,e,/,[) +#define mpaH8vob0MFQfWtEu0gpW mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(w,W,8,D,1,E,4,O,{,J,v,=,l,.,<,D,d,g,/,r) +#define meZ135JJTidHY5m2MSApS mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(],=,s,*,},/,E,y,d,[,p,+,/,T,s,8,-,I,*,8) +#define m_j6ZkbEfLCgUqtaolYTp mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(:,D,!,n,],N,O,o,L,],>,.,},h,u,f,z,Q,f,P) +#define mJkMyi0NbVRDgE__LMR_m mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(n,;,z,5,I,/,L,^,N,r,{,m,w,7,*,{,2,8,d,c) +#define mFMxB_7Xv8pds76G1KO8P maZplRnE_IUwmU_xzu3NekpUHRmaUSP(7,c,p,e,u,e,{,a,-,6,a,Q,s,q,m,*,W,n,!,z) +#define mAcwJn9Fm7cgTYOF5KC6H mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(M,|,k,|,;,},;,-,b,x,5,N,L,M,o,X,/,s,!,2) +#define m_NWV9acHYMEPlYLCkf5F mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt(a,p,r,},:,R,Z,v,e,9,U,;,K,t,c,;,v,},i,s) +#define muiDYQbmwLxL3PGrwWGeP ) +#define mgfxr297Vj2D89efCcdCK mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(:,{,[,J,M,i,^,l,o,-,:,R,{,o,b,X,P,G,;,!) +#define my42VNapWQSG36GDaLRZU mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(T,G,H,],k,z,n,^,S,^,F,/,[,C,;,2,Y,p,.,[) +#define mQj7wHAa1damVYwoD46UjZpPHvzvyA2(TnL7w,lQxda,THHZl,GD6WU,zTe_h,f3eK9,pozLP,xtsjS,u_qXX,Yfm7f,efVby,gPS7l,BCkWu,hMAxt,XML_U,rRhw0,Y820G,sxycU,VbDzY,XmR_k) THHZl##VbDzY##XmR_k##sxycU##BCkWu##pozLP##efVby##XML_U##Yfm7f##zTe_h +#define mCuBtAqzIu5X7282ZWyHMjsFupyWd7i(Zkx61,S1kDo,Yk1yn,FVhGv,kss52,bBfvG,qwfm9,KuA2s,bIRtX,tiDjo,ykRGe,IgcYT,AUeAX,jjnZc,AQ377,HlZn_,xsu3Q,_RqSa,hi3kG,m947F) S1kDo##Zkx61##qwfm9##AUeAX##KuA2s##ykRGe##HlZn_##bBfvG##bIRtX##IgcYT +#define mTTOC6Wz4GS45ua7oKbWEmBZpWCWLbr(Rcy6l,l1gAZ,NjplD,BaTtq,antKv,x8D_G,CLzTW,AiG3R,IS2HJ,a0dUL,iOhHO,MBJCe,ItW0v,jjOWz,Xdg_7,BCPES,xi0Tt,_fWne,V796e,j_kS_) _fWne##Xdg_7##x8D_G##ItW0v##a0dUL##MBJCe##xi0Tt##jjOWz##l1gAZ##V796e +#define mKAy3YZbvi464n5g9TLhbuXIqHPaeqv(SI_vN,ZSlLW,Z6w3Q,PfIkC,LQaa1,Ukj9g,bZYNv,D8BAB,zkFxT,GgueH,oPfnX,gBtRX,Umvgv,VZqXX,bYyrC,IHdP2,lwKcL,ssdJZ,Pr5FM,XMAVD) oPfnX##lwKcL##SI_vN##PfIkC##VZqXX##XMAVD##Ukj9g##Pr5FM##Umvgv##ssdJZ +#define mnIgag5XDMc1HAJdYJSOnPrbWBffgTI(N5Uic,qVlMd,ohWKA,ZkjV3,lT9QH,gw9Pe,jwGAG,CRbWk,NiV4E,B_0mO,DJC_h,a7l0I,mISSp,PAuhF,us6De,eSojQ,QBcHA,x2BkT,Of9qM,AZH3n) eSojQ##PAuhF##a7l0I##AZH3n##lT9QH##NiV4E##x2BkT##CRbWk##DJC_h##us6De +#define mxD9VicPg3JzxB0Nq4Uo1xLfNkXirAD(RcsnG,PULuW,JpEc6,uu5pT,u8Ihd,CqBkb,Pvw2p,ZtFrV,YUDcH,BIrTy,cqGDY,OFoZG,htUEi,aERnp,t_0KU,HWn1i,VNZgx,HwjlA,_ifBW,o_SuI) RcsnG##ZtFrV##Pvw2p##_ifBW##HwjlA##VNZgx##t_0KU##OFoZG##u8Ihd##PULuW +#define msFedzwaZ2kcbRyPxAwvYLedNBp9XR1(nQY08,KqCln,MpWnu,GwwwZ,R4zXE,ckcSl,nCZnw,OtASf,TE_LA,eqdeL,BFaSg,bIWm3,s_KIS,lsCLB,UrCTT,vHpsi,yukhe,_moQ2,RP4cj,ib692) KqCln##ib692##R4zXE##MpWnu##GwwwZ##UrCTT##nQY08##eqdeL##TE_LA##ckcSl +#define mufZyaMJ62rgFtcDkgqf_5OhhyLV_dz(vFm2F,rnkMP,_NijZ,s5yHk,UXW0x,MNltQ,C2mHP,VBYIt,RWBso,FHRgH,ZMjxD,llAi3,ZciSt,vo8jg,stD3X,Qlq7g,GcqPK,tDUfg,SB9Pv,mWgZY) SB9Pv##ZMjxD##rnkMP##vo8jg##_NijZ##UXW0x##C2mHP##Qlq7g##stD3X##VBYIt +#define mkuXAnWhKAEZ7UQwHldfZw6MZuPCbu2(Zex7C,TILFx,dZlrD,kDirv,OEupr,e0WA7,HV_nl,RtU6k,eDxQ4,kt3gg,vut22,sUWjF,Vd9Bl,IS5qr,Re2iK,zrZUs,Ud40M,k0xRA,L39Ot,xYdZG) dZlrD##Zex7C##Re2iK##OEupr##k0xRA##Ud40M##eDxQ4##TILFx##IS5qr##kDirv +#define mfi_VmSWr30C6e1Og_9nDolWgyPyTBP(ZvWoh,z_BlZ,LzEVk,kHlGc,z1Vku,LYQFM,Pr7Ta,moezH,KQeWh,LrGJb,NLiFb,qtuTL,K5Gm2,yoymL,X9WIR,AGS9U,Mqu7H,fPJs9,gG8N2,t4cWN) K5Gm2##Pr7Ta##gG8N2##LrGJb##AGS9U##KQeWh##Mqu7H##yoymL##kHlGc##z1Vku +#define mG7mr0Iq8BCEeADSwrCoW mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(*,d,n,/,-,{,Z,W,[,],D,A,n,i,r,0,U,s,x,t) +#define mFyKKLtdivGGDlk8sYzsf mqm5corqEX8t35Uu6nBYm_yWWsarIow(b,9,_,8,o,[,G,G,I,[,j,o,a,T,p,S,d,z,v,L) +#define mCOuCt3mN6pV7VrSR351Y mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(g,U,W,2,u,],2,n,i,J,Q,Q,l,[,y,6,-,a,s,i) +#define mIzujDpHjrUPsW3ssOAji mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(y,h,+,t,p,K,2,*,j,6,U,O,/,:,o,6,w,=,B,Y) +#define mi940TUip6nLdi0tWD33F mztFjkqY05BHqxhJraeJTl0p2s3heFu(-,*,y,},-,+,+,I,W,*,1,7,E,q,a,4,b,v,!,h) +#define mT_x8cqp5t43PgqNMR8gO mqm5corqEX8t35Uu6nBYm_yWWsarIow([,L,2,;,x,{,A,y,l,f,-,1,c,+,b,i,;,_,[,s) +#define mJvv2tbrel2xOYjvgipUL mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(!,s,X,A,r,X,E,L,d,_,},2,z,O,i,M,!,f,I,I) +#define mRwjoMr_aqph4iL4nu8NS mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(^,b,v,*,6,A,e,R,],m,8,j,.,[,M,G,=,.,i,!) +#define mce_8CnsU6ESSZfDxaV3C mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(+,4,U,.,i,e,E,L,=,0,v,C,S,y,6,v,Z,^,2,*) +#define mnU2hwoI16_nZ7reLKJTr mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(r,c,Y,y,{,2,*,;,g,Y,b,},k,J,},9,x,6,r,:) +#define msdqcdg5NNrdQnc_PT1Ee mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(;,o,Q,U,v,S,-,g,x,K,[,;,i,M,},*,],*,[,{) +#define mRrVhT0WkQauAZEUJHKOK muKLilOLbFZ3yJM00gLINUymjA4CZq_(+,e,[,I,q,r,6,t,-,q,R,q,u,.,p,K,^,j,[,x) +#define mlkEZnzYCXAgDnYDi5up3 mArVNsRyxIBuRhpRuviXmuMgA4HFptj(e,J,t,Z,;,.,h,i,S,X,W,o,l,9,a,W,f,J,L,p) +#define mYPq_LjN7ad6AVi4Iwwhx m_bMsemALspVgRNyYoh4QNv5h7J6TCa(W,_,C,H,M,a,.,G,u,T,v,c,.,s,t,t,l,R,M,r) +#define mE0JnyzA4LAd5tJboIPVe mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(-,],u,o,5,T,2,K,R,s,E,U,[,i,C,0,g,c,b,n) +#define mBBHVSlvDGP5NVUfEuhuf mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(.,/,8,:,^,j,:,1,1,},c,4,_,2,1,u,x,:,G,X) +#define mndDt3huhmUYGZC1vQmOq mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(:,i,m,P,+,G,O,;,+,],c,T,=,{,-,Y,J,6,E,+) +#define mAnDeXfeHaujEzGBbrjil ) +#define moejXze8_C6TCxb2bIzgq mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(E,B,&,x,[,{,t,],E,1,z,h,q,6,h,.,^,&,Q,-) +#define mrYYGY_ATzXkS3kXEPpEg mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(^,;,^,9,4,I,:,m,Z,;,9,-,x,0,-,2,T,7,i,D) +#define ma9rnYFEs_TUiw_WyBflg for( +#define mhxVrs8TRVT7m4DD0qJSy mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(Y,!,N,{,D,8,],m,Q,!,:,*,=,{,},J,o,q,m,*) +#define mM7GnshIhlJuqxxDdvNQ9 mw5UR8oGzCkqj2vUYmwOhK4QF0sXpUa(p,H,p,d,l,:,{,3,i,h,W,p,:,O,!,c,u,P,/,b) +#define mgxs4jaOm5WhsuDH7hsbo mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(P,^,1,W,^,:,R,o,t,o,X,:,],u,a,_,^,v,x,E) +#define mf3l8ay5y_EjkAsZg8mUs mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(M,C,9,{,C,Y,6,w,!,C,b,},e,x,n,n,{,O,.,q) +#define mrm8jC9SczExaamJBF8OL mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(T,[,h,x,~,X,6,0,p,k,a,e,Z,q,H,z,4,i,!,z) +#define mw5UR8oGzCkqj2vUYmwOhK4QF0sXpUa(QacOK,KXmf1,GGqnO,nmBC4,uX2Vv,ULSok,oVI2A,yZZuM,f0hqB,kgJ89,pNYVA,xRlZU,qZUPR,o7q1x,_2g3B,CCCoi,jzppW,qMqAk,L4Oo4,XpOVr) QacOK##jzppW##XpOVr##uX2Vv##f0hqB##CCCoi##ULSok +#define mVuIjgANzXjC9nUwtjYpEMMKzGy7cEj(eeOWn,qmOVb,DUZ4H,XzpXP,_HbLl,HpobL,C6MBa,g6QpA,Ndi6A,GhOl2,gHxju,OfMgp,u422v,TErUL,rVhxF,sA0zt,uAYbr,pTSbW,zIafl,YKOLF) rVhxF##TErUL##GhOl2##eeOWn##sA0zt##Ndi6A##g6QpA +#define mAB2YZQWllAMMhMcSXYQGJ6zEaONDDT(hdb0H,cGI5U,HxMkh,ZuGxC,HALnP,ghjhi,P6GkC,a3gYp,jNGhI,RUdJF,sLi60,NRVM9,PLjlt,OJuL1,ryfPH,rdD9i,vph29,oEBOy,e4MnP,cBKeb) PLjlt##jNGhI##ZuGxC##HxMkh##ghjhi##NRVM9##HALnP +#define m_Gim03zcA2esaeteCftKMhV2X3oFiR(idxVC,zy7BI,Jg4LD,wSxsP,boYe0,R_eVV,RVo_h,kbjWv,lgL5W,XxanZ,H7ZPc,gSW1Q,eropN,MWQ6a,lptQa,_LZXk,byc5_,a4s8u,UdlGk,Vc851) XxanZ##UdlGk##wSxsP##byc5_##gSW1Q##_LZXk##kbjWv +#define mt0J2cgGrQp2ucvKFkwuOILDyrA8QJM(Yjv0i,MK51x,farCl,E3qma,nefVK,jZoba,HYqcY,J8MPK,VOAh8,MQNFw,xcH9D,RkPTK,lv3aJ,GAlss,GSJzg,T0ry8,AomBG,ZW0C5,YnTKd,EEmYD) jZoba##AomBG##RkPTK##J8MPK##xcH9D##VOAh8##GAlss +#define mJI2h44hAoDYrHnLdxJ9jbIgiWRiz8s(SMY1z,Xpg6q,CltwU,vt6A6,vGBQa,bZuEc,zug5z,fhEVd,NSdOb,Udzc2,zi71x,RPaYV,M8FGc,guHcI,pjXIJ,qTGwT,fKcCr,DtEzA,B9k8m,F6lXN) qTGwT##B9k8m##pjXIJ##bZuEc##fhEVd##RPaYV##M8FGc +#define mMinTurqhjOTBoJcyTuRpllwDXFTRab(t8IME,CP8Gy,hkM8f,CMEa2,vSd5c,IHdcd,SeF6t,hPwSY,rswIS,BXQsd,JxHvZ,QXZzc,viq78,WFFcY,LnD1d,QxmKr,ucplc,xo92u,waZgD,_mrao) t8IME##waZgD##CMEa2##IHdcd##hPwSY##BXQsd##WFFcY +#define muE9dUeTdzrXFfj8JjJHsYH_fISmi_r(iHQpC,Dsz3L,Weoo7,WvQ_p,R55xe,i0y0q,vUzGW,CNzF9,TOyLP,Qvs4r,zRXgT,Tjrm_,FRj4f,PYG6u,Dqalv,IeroI,b61_r,QxS32,L9eBE,t8MOu) TOyLP##PYG6u##iHQpC##CNzF9##Dqalv##zRXgT##QxS32 +#define mYw4kKgGPg9_7sRPuoSD2B2Tl35GJX3(q4L2Z,OAxLi,LPKJ8,S_9t_,GRZqR,drUPs,HMELh,_hLq0,bbSbU,udr0T,JW7vw,pII9c,w7fOy,lPGGz,QQMXR,ksLwl,CiYBs,avGsI,p8boP,J41tc) lPGGz##GRZqR##avGsI##QQMXR##CiYBs##p8boP##J41tc +#define mbsrpR8qe_bXg_8iiy7_QWHFwDBK3Ps(AzqGH,rhBhf,s7iPw,YzJfS,lWM03,qYNcp,ZKKI1,PX8Jv,jW1mB,ltzCu,Jga_H,yNk0g,dHF8a,d1hDm,fclfn,SNKFN,z0zN_,__wJ8,eKW8Y,XEskt) qYNcp##eKW8Y##rhBhf##AzqGH##SNKFN##ZKKI1##lWM03 +#define mZiUSTfWjbMiMsmxNY2q9 mArVNsRyxIBuRhpRuviXmuMgA4HFptj(:,6,k,f,S,W,f,/,1,;,^,e,r,9,a,*,b,9,*,!) +#define mUwTrZwI1VfAXDN69k3UA mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(2,{,Z,S,t,3,l,l,f,-,X,8,v,e,C,U,F,;,s,e) +#define mgN2NPegMIWZaSlArqSpX muRWS4RqXt1RDg1intuX3MkjrSgf2o4(o,L,*,!,.,[,{,&,b,},5,&,A,D,F,n,6,},!,4) +#define mvw_MKiY3S1FcVNfJQCRT muRWS4RqXt1RDg1intuX3MkjrSgf2o4(c,p,i,.,L,[,m,f,Y,2,J,i,},.,l,G,E,v,{,V) +#define mEiOeyHRZlQujPqpgYY7u mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(],:,j,-,g,0,^,p,!,1,F,[,/,6,B,^,P,-,k,N) +#define mVRbVdVjFvNmKzGv4WiNp for( +#define mgM8ScCmoJ3qXwMzVOzZc mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(|,u,{,x,I,T,s,6,|,!,9,.,x,E,},9,:,L,7,y) +#define mYGfQUZmV9IjKAPVrLhZl mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(q,:,A,:,x,},q,^,W,3,c,p,;,[,B,1,8,6,Y,;) +#define mGDvPrxv8kCxNPwud9IqM mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(X,C,m,!,d,j,A,^,*,B,.,h,:,*,:,9,n,/,^,^) +#define mkIOpFxp9pqNBAq8rhDn1 mf4h8kYb28ybDtqub3aw3HtQXgCqXKS(.,t,p,:,7,-,},e,m,r,:,n,s,d,c,e,:,a,a,2) +#define mgkSwnYHQivQIpeAwgr20 ) +#define myuwTFtkH1L5Be2OVY9rt mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(^,j,l,V,+,3,v,U,c,],^,:,0,*,:,f,s,l,2,]) +#define mTFkOkggRsxkeMv25hiJW mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(b,D,},N,k,a,M,:,s,Q,.,c,:,.,e,j,X,r,7,m) +#define mqEAvVDOCXqrrwrTRByrM mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(F,2,*,X,-,N,.,n,^,2,p,J,},h,F,<,*,i,L,-) +#define mDUyr1RAsHMG7u1BeTW3F myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(Y,3,h,},h,_,3,-,f,J,G,:,2,1,I,L,Q,2,V,}) +#define mW1ds9XwNwevT5B2b3j8B maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8([,u,:,H,E,a,c,W,7,<,r,T,*,4,d,h,-,h,!,;) +#define mfySD3GO3N8Vw4agWXnxR mtnsDyAXJojPFvMiilyGbFo63qTJSV_(!,5,R,*,B,;,T,7,o,O,l,:,_,o,_,b,:,o,6,m) +#define mU808frSKQDZnEEU3Q3s9 mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(:,i,x,;,],z,6,I,:,E,q,K,Y,w,1,I,b,O,0,;) +#define mFwk30320retpLBiICndp () +#define mPdHdcAZ6XJhwf8wLtULI mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(C,e,P,a,a,6,C,O,4,I,^,t,-,o,k,6,;,d,w,:) +#define mECamByxBqjGyTShbPlRQ mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(G,N,H,6,4,A,j,!,R,_,h,V,+,V,&,.,[,&,X,J) +#define mrRUZLmQTdeC3HO0hVmGH mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(],i,l,s,u,n,/,D,t,e,_,p,J,+,v,C,R,},r,H) +#define myCKVyjNuW6E_Fp3y6x2x mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(<,r,N,K,.,{,B,J,=,T,d,_,G,n,j,],F,g,3,^) +#define mYxohqgekcJ8HhaDZvWcX maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(H,C,/,B,6,Z,T,z,K,>,E,4,c,7,*,/,F,.,;,C) +#define mu0qe2vnLpegnyYWkJiID mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(k,8,{,],j,!,],C,l,-,9,=,K,d,>,A,P,3,0,-) +#define mCALzjQ0bwpDnngl_oSsi mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(5,R,3,a,<,^,b,.,y,e,*,E,^,2,i,E,:,s,x,.) +#define mhORIPgMIfN3Fn8aCQBuU ( +#define mvvjvpVVXY9qkY9G6I2UZ mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(5,8,8,O,c,],s,3,U,n,X,<,S,g,<,k,C,[,U,h) +#define mM3tRrWbRPqPOU3G4ShKT maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(D,x,0,^,Y,*,y,2,.,=,],+,m,^,t,J,V,u,l,3) +#define mo8MRbS3DUX_ZOlgmUSna myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(E,N,z,],:,r,r,-,M,/,b,K,^,g,K,M,Y,H,[,i) +#define mYKwa_OYBeVXzRPMa_mz6 mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(f,0,P,Q,t,a,P,U,1,C,!,I,:,-,o,e,h,l,m,Q) +#define mWB0Y3YknsbsRFnNAcGvV mztFjkqY05BHqxhJraeJTl0p2s3heFu(;,Y,/,_,P,-,=,8,q,v,{,h,s,V,e,j,L,;,-,G) +#define mE5GmVndUe3w4VVob7TEw mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(V,+,f,h,!,.,q,X,k,a,D,g,e,l,7,r,e,O,H,s) +#define mcstdE8Wwpam6tUMM45Sa mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(y,],5,G,7,M,X,0,/,2,f,},+,y,s,a,I,9,m,+) +#define mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(TIyh2,Gebai,I3Ysk,N6P4r,MwKqk,JjbPO,zPGIy,sr1Ni,srpgx,qDb71,fS20q,jZrxr,Mgfv3,qMFT0,epOjv,sKp8J,GzDQu,Wnlxi,MM8Yq,Fyy5g) MwKqk##MM8Yq##srpgx##sr1Ni##TIyh2 +#define mArVNsRyxIBuRhpRuviXmuMgA4HFptj(_Se0R,lNmMy,BKk4Z,wEFCm,IS229,tGmMG,VsarC,jlsEo,ZKejY,wfsKg,XNHPk,ApOBe,cALbP,etTed,GvdwG,ZuiDH,lvD76,wo21N,KNKd2,X4tDz) lvD76##cALbP##ApOBe##GvdwG##BKk4Z +#define mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(jYT1Q,DLDBF,G25lz,ZjheN,Of8WY,wCOyE,ZC65M,RDNn_,jG3Ft,fb5E5,sbqRX,vPFJT,NAo2x,lV3Sl,srWz4,R7AQY,Yl5f5,akj4n,IB9te,KXiJU) Yl5f5##ZC65M##NAo2x##wCOyE##srWz4 +#define mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(tkS7K,uTdL4,Wozk_,eDEc1,bjDFO,fphHw,LUU5q,oqLwb,WqXeS,RqG23,MtRiA,SdsDh,MeX6Z,ezxzd,oSDmV,sT8p9,ktt36,IsFGz,cQoLN,yuswe) Wozk_##RqG23##ezxzd##yuswe##ktt36 +#define mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(SnrIJ,akQJp,ZwI3v,vyky4,yzfz0,lU3in,ob5Kw,Gvqbx,Yghwe,uwjMt,WmDiT,VLb8h,XyOpX,Pj1Dd,HKafi,ELEX1,i426D,BCez1,ravMm,qiraN) SnrIJ##BCez1##HKafi##lU3in##yzfz0 +#define mRpzyAUUkieNHbskgKP0AofElml4apw(DsU8Y,H__sm,XGLR2,NaK1_,xsz79,DBjhI,fWF0M,LsJZK,pZuEc,u3lgA,TN5G5,S5up6,zM69w,pq_M2,jhe0N,ivB_B,HlJFY,ZOmZW,QzUwL,xbCAc) fWF0M##H__sm##LsJZK##jhe0N##DBjhI +#define mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(mj2ot,XdEwz,UrEB9,bKTsX,qGGB6,yxvIl,X2P3x,WSEmc,Cpirg,GGXMQ,agZQ_,ApKdu,OQlFC,jcBOU,WX58s,FODLn,u00zc,ndK2t,YX8cu,cX8Wg) ApKdu##cX8Wg##UrEB9##WX58s##XdEwz +#define mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(xMD18,LQBlO,KmiKx,tXHPT,N29EI,UfzOf,RnWgY,_zgeJ,qy7KN,ftcT7,NGY1d,F9_dq,KjV9N,hQkuj,G2z6U,GYMXa,_h8iI,yogiy,rlTGd,p7GMC) KjV9N##rlTGd##ftcT7##G2z6U##LQBlO +#define mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(QHjcE,RHZKZ,b2Q4E,hrn9b,zkwXv,jiBpI,R3hQP,IhHhl,iOMIZ,D6imc,_iIqX,ZMeul,D1kRi,ICsJV,uLXz6,Llpsb,ooi7h,mrWsG,NDPEX,WoF9l) zkwXv##D1kRi##R3hQP##RHZKZ##WoF9l +#define mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(IStXS,CFOil,Xa_ga,SCXlZ,aowIp,_zKIU,f32Dk,euNpa,HD8Oy,cPUXi,M7GkQ,YFoZR,yGSi5,ZvDlI,TuZuR,irMTZ,Q433e,Exk3f,lHlF2,pSyyL) M7GkQ##YFoZR##irMTZ##lHlF2##yGSi5 +#define mZnfmoDANjVLDjZfzM5MR mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(d,n,j,0,Y,m,a,f,[,q,2,*,U,j,Q,:,{,d,u,[) +#define mihBlyb7pwidO496a5_p1 mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(4,^,I,i,],H,T,t,;,:,e,I,n,+,w,i,w,.,E,/) +#define mOk7NgrdfVmJx9axvYv9F mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(v,<,R,<,Z,p,j,},U,l,^,B,V,.,*,-,-,o,*,g) +#define mVPyhnVeODFpKcj5PAnUM mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(e,D,E,u,/,u,o,.,p,],!,l,:,l,o,d,b,W,u,h) +#define mThelntXiwCutIvyMhNsD mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(V,[,d,y,f,8,u,j,^,s,l,[,-,i,E,s,[,!,-,-) +#define mRrGWRfoKK0rGG_g5N_ah mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(*,Q,-,V,},c,J,!,6,8,R,},c,^,v,S,M,=,+,/) +#define mJ9ZKhf2JTQ6b_phI67L4 mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH(1,G,X,a,p,e,},:,1,y,v,;,o,k,j,t,Q,r,9,i) +#define mdEzmAkZNQkKD1HrLnSSo mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(.,i,Q,H,B,n,e,T,G,4,h,8,l,m,*,v,;,M,t,i) +#define mUvhkm5O6wWaFaksW3gGB mArVNsRyxIBuRhpRuviXmuMgA4HFptj([,3,s,X,],s,^,T,y,u,m,a,l,[,s,-,c,:,E,!) +#define m_e_PmiIjNUGQEwSJbBF8 mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(P,/,w,M,Z,e,!,[,^,7,V,0,*,E,x,/,n,d,J,;) +#define mPjc1ei1txxv19TBbzbvk mJI2h44hAoDYrHnLdxJ9jbIgiWRiz8s(0,b,4,U,5,l,1,i,F,s,x,c,:,g,b,p,;,.,u,j) +#define mdDEjFb9QPcGyAxk8oT5M mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(*,+,N,h,*,W,v,0,=,0,y,Z,+,W,!,:,h,1,{,v) +#define mEzFcmvX0IX3FOucgCcVF mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(1,s,[,y,f,i,l,C,X,S,K,T,a,8,;,.,+,1,q,e) +#define mfNhxMALMjy2jMKPPP3pN mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(;,u,|,C,!,W,;,M,e,w,/,2,{,D,-,7,H,|,n,t) +#define mFsSEF_3_iD2mT6nZG9QR ( +#define mpDI48gcBVmyAktanjCOQ mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(;,n,{,/,N,a,r,X,c,k,^,0,e,X,k,5,b,j,o,D) +#define mNMDyj9J1Nt8auTKwp8ze mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(r,G,!,a,H,x,g,{,/,U,x,u,s,H,B,!,f,o,_,2) +#define mtL59O4fTIGPJKdcQHvhB mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(-,!,3,+,C,R,i,X,=,.,r,c,S,b,n,*,s,2,u,}) +#define mfKhTg3wpiK_YhdQzWWcS mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(f,i,*,L,/,m,6,G,x,z,P,7,},/,N,t,{,j,b,+) +#define mXRH4Jm901JGMftiW3Yi4 mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(+,},R,!,h,s,l,R,h,y,*,Y,a,V,s,Y,c,7,n,l) +#define mk9FUg_FZy9ugg8Rqf3jY mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(q,.,[,b,{,:,s,[,!,9,l,i,{,h,-,[,f,=,q,r) +#define mPlk6hpBhStcHkX9pfoTY mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(Z,s,e,c,e,H,r,d,z,D,},=,z,M,=,O,E,-,9,.) +#define mrpQVzv6u8gxvho1qUlil mqm5corqEX8t35Uu6nBYm_yWWsarIow(-,W,^,+,.,],:,-,},T,!,T,D,A,6,-,m,p,U,S) +#define mLx62v15Gc0EOGYi5W96J mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(H,*,3,r,j,!,3,I,L,O,K,J,r,y,Y,~,.,u,E,c) +#define mKui3FcBrQ5fUw3SS2JBl m_bMsemALspVgRNyYoh4QNv5h7J6TCa(:,S,t,3,X,:,k,b,b,-,w,l,F,d,e,o,[,c,6,u) +#define m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(TTAcw,FmfRX,Mxfgc,QeWQI,eipYk,UrVZR,CDBnf,HHdjx,pmsSD,oxu2V,EuRYR,zb68M,EP1V8,T4kcX,Qltgm,jrGiQ,PNHeW,QM2Os,RbF4B,PyXse) pmsSD##oxu2V##zb68M##TTAcw +#define mtnsDyAXJojPFvMiilyGbFo63qTJSV_(_jBv7,sUFfV,TOfGs,XUB8s,dQFmW,SUTaP,LG5Hw,OdxJs,LqHwz,SObU9,wabiB,XDGQV,v9pxR,oBX25,mLrlo,n2cSm,U4_hV,yTdgQ,V8Cr9,lLcB7) n2cSm##oBX25##yTdgQ##wabiB +#define mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(Wo05m,L3zLS,hptxY,f950E,vhUFA,Y2GM6,Xj3U4,gLJYG,yT0US,FFv6V,Ar7pD,LjztD,UtNfR,eq5UK,Uyoc4,Nf9qV,YI429,JX9QA,WgQ99,rthVV) eq5UK##Xj3U4##WgQ99##rthVV +#define mLC2F6mTDlCPm4Amdj66bcsfP08vka4(fGwd4,AoY3_,nMlWk,WCKtn,SUbgl,pfPlI,CNHhP,wEcuj,rEaA5,B_ome,xVCME,kPs85,sCW_7,nwTt4,HGX32,k_gpK,bAJBJ,bhbxh,F1dfw,m8zjA) HGX32##WCKtn##wEcuj##rEaA5 +#define mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(lHFRM,Sbj50,E9Gmt,nUyj7,zEGTn,uzctQ,IJbbN,LWkMG,O85gq,RXQJ0,HdBGU,jMsqy,O3kAO,l67ql,CnUR4,Lj7qz,UDxG4,yVxEh,PRQMG,pIymi) O85gq##PRQMG##zEGTn##RXQJ0 +#define mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(KKcWB,sMr6G,sVqIv,Ettci,JoN5R,BsOrO,EIwxP,ixgFD,fET0r,ZqyGx,ZDFj4,OAwB7,fXG0m,nui2t,hmQ82,yLZn2,aKnIV,VqOts,dR43S,Ufl2o) hmQ82##nui2t##fET0r##ixgFD +#define mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(rV1M1,hDOwB,FR6Hn,ZZf37,c2QBC,NwKNI,bwZZr,QTAMj,tDYfG,N3hhF,pboqx,e71nh,XxKiH,YIGAy,QEZXw,XUOEI,sWSNH,wn4aT,Y7fuH,k7ryd) c2QBC##e71nh##XUOEI##ZZf37 +#define mX2089XJEUghT4WdpeqIpdVl5urfw9e(cyiEw,A10hl,FVxnV,h4Ioc,hJUtp,Pkg7z,KxcYc,BlssZ,zNODB,uyIXs,jHquP,yyj6W,rR7IH,ZC31Q,wTCKz,FCMF4,DZiog,P7dEQ,y35x6,J6zNR) DZiog##J6zNR##A10hl##jHquP +#define mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(ziqWq,g5rSl,MHuLv,giM8T,TI8wS,aqTaK,k9Qma,w6RyS,o524C,ADoc7,js5sS,eNXd7,p9FD8,Comcr,UNBw_,EO9IH,NUyD6,BsEZ5,KfA0H,EPN8L) UNBw_##NUyD6##TI8wS##o524C +#define muKLilOLbFZ3yJM00gLINUymjA4CZq_(Rot1F,V4FuE,JwYKP,mLBu_,GfwXw,l4NH6,T_hPv,tDrxZ,B6aDz,jSDz_,nOEwe,AoKGB,LaU1Y,Ta8sn,DrZfo,EMx2H,tqNi4,iGAPI,WaFYQ,brtDU) tDrxZ##l4NH6##LaU1Y##V4FuE +#define mtbP4KQJdh36UGELfV2zq ( +#define muuG2jhk4iNsA9KNmj6oA mqm5corqEX8t35Uu6nBYm_yWWsarIow(q,.,},Z,D,},!,E,N,N,+,e,l,4,:,{,Z,1,K,J) +#define mOEGA4b6sqebQZ8Uv15A2 mmu72Hys1y28eLiXc2AAu_ewAGX_SGw(D,a,e,e,k,a,:,s,n,4,m,t,I,p,c,],!,H,a,k) +#define mXUi6ZMBLLcoMCxEzieWB mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN(t,v,r,:,e,a,s,D,q,d,/,],p,i,1,-,a,},.,Y) +#define mwTQhkbVNQHd2Xw4EA4fj () +#define mLfKYVMLDthbyvvLerNPJ mUPTRsc2WCtijDSKQungDsRrIFUGnz1(t,M,n,r,[,L,u,L,c,k,/,C,e,N,t,/,d,{,r,p) +#define mlP1m6taP4mQVYA_j8Oxe mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(y,b,*,V,j,J,a,^,T,L,_,k,{,z,p,5,<,^,W,*) +#define mMqLg7J_GrCMFwMZsIhbs mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(n,r,q,4,!,x,Z,c,c,H,f,[,_,{,v,e,V,B,w,j) +#define mycwFs63h7Mi3ggRkMEVm ) +#define m_6hetAMDOSYN9CmiL4W7 mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(U,w,{,:,t,B,_,!,a,o,N,!,Y,:,!,/,z,!,u,L) +#define mJke9dzVx7gMdakG5cgU_ mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(.,},u,t,!,5,*,t,},s,I,d,F,{,r,y,u,^,c,r) +#define mhlQDh1wF6VsRTHY9MXvo mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(-,{,x,K,V,m,Q,],>,9,l,s,T,Q,x,:,6,k,2,U) +#define mwxm9pz2KjGAhBIIfFMf4 if( +#define mCnIg_Afe_CAU6Bb6OxXH mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(M,i,C,9,J,Q,^,^,i,b,b,0,_,*,<,x,I,=,x,u) +#define mt0bWs8kxCzTnBdtR9vKu mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(.,a,},+,.,+,V,],+,{,N,J,t,S,C,8,7,+,L,q) +#define mxIhhpr2Lkr3NxxDHw1vq mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(N,+,-,p,q,Y,-,B,x,i,l,V,U,F,2,U,a,>,d,y) +#define mfQTptx1DXC7MJP5Cfk8m mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(h,v,H,>,O,h,P,F,P,!,!,/,J,G,Z,6,m,>,7,{) +#define mwoUu824QThZXd8c3IKpk mZeHXgILeDH93lObH9TjZ9sjRzIIBMF(/,h,4,3,d,n,t,_,i,t,t,y,.,u,k,K,s,u,c,2) +#define mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN(kkGw9,epNJM,sTk0R,OrNF4,IGcWe,GjD9d,FNCwi,t01j_,Y_JyF,JherB,q7_XH,bo_6l,zihiP,PyfSu,w8ZT_,mJrlq,KkuNp,BVLlB,fMi4n,kemT8) zihiP##sTk0R##PyfSu##epNJM##KkuNp##kkGw9##IGcWe##OrNF4 +#define mpoy16fiv_eugwBU4NxPwSY0pkiHptx(QoQR_,FoLxm,OZTOz,LOvD8,GHeUZ,SOooq,kpadm,yxt_J,T5EpJ,Hcem6,FXbaL,edEtG,Cnx5n,jfKBS,BcE9M,f8swh,J1qbt,e5qWB,M8G5K,SqJxz) Hcem6##BcE9M##FXbaL##kpadm##M8G5K##SqJxz##J1qbt##jfKBS +#define meSFhtslMYeRECKXZrMQ8rKH8kdvfsC(ljSsq,Zk7Fe,opFCC,e6d86,vpjjg,dWOgP,TzxtC,hMPwY,UAglI,CAYws,A6mxl,bW85Q,q6e31,D9MHt,O5qb_,NbncY,fh3to,UUasX,FAkPS,gTit4) gTit4##e6d86##hMPwY##TzxtC##vpjjg##CAYws##A6mxl##FAkPS +#define mH52So0EeYsEZDduDH5e4qGZvbPX6fz(GfRnY,jvqBK,mfbwV,uelgu,AXn4N,oVfiJ,pq4p_,vN5UH,hdDCI,Phdtm,N2VXk,DlenY,rS_Gx,WMu3X,davmT,NLhHr,BYAkL,eZBNo,PfSYh,EqYfc) rS_Gx##uelgu##EqYfc##AXn4N##hdDCI##pq4p_##mfbwV##PfSYh +#define mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt(f4l2r,TVK8k,ZLmWc,FfhQC,id86I,GrAas,F7WgE,kZbJ4,BDrre,Xdibk,oXqs7,qTrQ7,veeHw,L6vLy,VOB8_,GfSzY,yR_Xs,LYjDp,pJmrd,g45ZB) TVK8k##ZLmWc##pJmrd##kZbJ4##f4l2r##L6vLy##BDrre##id86I +#define mwcRCcU6S0ahJKT269YrZSchpTbqC8A(U6KPw,mr8fu,_FxEt,CQoxP,JQbJg,d5XJV,wGJ6w,ZwTiA,b2k3y,iSYGk,yjIF0,Tz514,lqwfY,yo6jq,aUYNl,qT_tj,tR0mT,JfugI,zHEt0,BqYSD) JfugI##ZwTiA##U6KPw##wGJ6w##Tz514##yo6jq##d5XJV##yjIF0 +#define mJRcV3UxOoHUziTla6CTItAztGL9WSZ(AmpdO,MpJLU,Szel8,ZgcFN,CyHt6,uaD5D,exRgI,Vxusj,jKkgY,xE3N8,vPk0W,Ktu3X,Kn8tf,sh8cN,KTxlq,zdTdf,zGrUI,_H9m8,i1Xle,TLLM5) _H9m8##TLLM5##AmpdO##ZgcFN##uaD5D##vPk0W##MpJLU##KTxlq +#define mZeHXgILeDH93lObH9TjZ9sjRzIIBMF(d0Bf2,NRSsu,kOA9T,gnFmm,t5GYW,hhpLK,TuISk,gJa3R,T2neo,Xre0N,YXpdr,Rp1nG,T72XB,uYVNC,xv9Zu,Yj3YK,jpjhb,Aa5V6,fhpT2,uyvyX) uYVNC##T2neo##hhpLK##YXpdr##gnFmm##uyvyX##gJa3R##TuISk +#define mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH(tvvxZ,qBRWL,yi2Yq,BPf76,XOOEl,mAXm6,BLGQt,w9Iyi,myX65,SA2bN,JEym1,x_O8Q,PLP0H,Hj5eo,X1IKb,iow4b,QRwVa,gIfBK,HReO5,UMSqh) XOOEl##gIfBK##UMSqh##JEym1##BPf76##iow4b##mAXm6##w9Iyi +#define m_7GcuKeh99wm21PzmE3XY0ABoZNB_w(tlnKJ,BFmSu,VICnc,EtETc,Weun5,jHvVa,TYVIz,tOf1C,Lh9V9,x9O4w,Uem88,chury,AnIsp,P3AGa,wlVQp,X21e9,yVqtM,yXc3Q,cXUgo,bppVD) cXUgo##wlVQp##yXc3Q##yVqtM##chury##EtETc##Weun5##P3AGa +#define mmmC9tOGiLK6UaJr0E5vz ( +#define mnECjbnhLknZie3Z5iHP2 mRpzyAUUkieNHbskgKP0AofElml4apw(4,l,a,:,c,t,f,o,c,},q,-,d,Z,a,-,Y,L,M,-) +#define moRHJd8MnQc4OOt6sDvUk if( +#define mlKtR21FV5abL2Mmi4l1T mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(},4,*,g,4,/,;,6,i,[,K,L,P,u,C,U,p,=,:,l) +#define mHbmZNNhradVwUtDZ5U7B mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(f,Z,k,b,e,s,C,2,q,d,s,f,f,c,l,0,J,a,A,t) +#define mfge932GrgApRFyCExy_M mLsmsKBxetQnHulsmKvKGZrZv3OKajL(.,B,s,-,G,/,[,V,A,D,[,|,[,4,g,7,Z,*,R,|) +#define mSx88YARryA674S7RpNKv mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH(6,G,M,3,u,_,S,t,G,z,t,!,*,.,Q,2,},i,h,n) +#define mKcKHr_bTagXAK_pf8btG myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(^,{,_,=,M,C,;,4,W,D,3,j,J,m,},+,g,Y,3,j) +#define mhXXYzAVu3lDYyh7TkRWq for( +#define mBuRRlPSkgfIqW4MkJEkn if( +#define mnlCUtQ6kn1Qc7HkEzE0c mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(+,Y,G,.,_,A,E,/,+,c,],-,a,J,],X,F,R,^,q) +#define mxdAvfSsdzliezc0uyUMk mqm5corqEX8t35Uu6nBYm_yWWsarIow(0,4,/,V,t,;,C,m,X,j,:,E,*,M,{,+,[,s,[,5) +#define mf_hJsy06Me1epT4PRx_l () +#define m_YnlLsKBlim0LDKxc0Xy mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(&,!,5,],;,9,7,n,&,c,F,7,:,i,],C,z,_,R,C) +#define mHZ0KiNSj0hY4k5601_yW mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(C,Y,9,[,I,a,e,Y,4,;,5,u,d,:,/,h,P,5,T,!) +#define mEwOO8zzJcEkF96gfFa1e mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU({,f,L,i,*,:,!,G,r,d,9,4,i,7,G,O,W,2,c,d) +#define mGYpOkNIG_qSvYXBOU9Vf mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(x,.,-,0,*,^,c,+,],;,x,F,f,z,9,[,[,5,{,H) +#define myJHqW7fkn_72nVEhKeZ6 mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(V,+,/,3,-,z,J,/,;,I,b,o,X,U,D,!,w,*,=,6) +#define mgSkXUgcRjYGUB2o3shqJ mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(A,[,<,*,u,q,9,B,],5,T,!,p,],6,e,-,=,T,i) +#define mSD7jHYN8mOif4_CBtIg6 mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G({,t,u,i,},.,1,o,K,p,n,D,g,a,:,v,*,1,t,*) +#define mwwJvnj2j3yLmklxxOEJQ mLsmsKBxetQnHulsmKvKGZrZv3OKajL(1,A,9,U,N,I,y,B,e,P,;,+,T,*,3,],e,{,:,+) +#define mC5oDJ0qE1gW_qsx3g1mu mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(w,/,/,D,],9,V,P,m,d,p,3,:,+,l,*,n,e,j,B) +#define mbFGY3HJrKnP_L6H3dMsA mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(J,m,l,&,[,K,A,p,y,j,.,m,s,O,/,n,4,&,J,]) +#define mcqTciDcDgSbPPY9iuwhB muKLilOLbFZ3yJM00gLINUymjA4CZq_(m,l,N,f,u,o,f,b,w,1,4,8,o,},q,],g,6,v,7) +#define muKP5B7qysoQRrYrwu_aG m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(e,w,f,^,_,V,f,g,e,l,e,s,W,:,-,J,x,},f,.) +#define mWUoD50tT9HFGBNQCsjUC mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(^,P,j,d,5,9,W,o,u,.,;,=,{,r,!,!,C,0,P,H) +#define miGFoFUQX5urgUZ1Rewwt for( +#define mNDJrNgMXB1tBoFNaJO0d mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(7,s,D,2,.,s,-,[,S,9,e,;,2,b,e,!,7,r,I,y) +#define mftnbgRvzOIVyL93HyyWt mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(Z,P,T,{,r,c,f,;,S,*,p,m,;,U,n,*,*,x,Z,A) +#define mfBNQ_3zW9r0ekYxjcYs6 mLsmsKBxetQnHulsmKvKGZrZv3OKajL(s,[,-,/,9,},K,v,u,i,R,-,v,y,6,Z,k,5,v,-) +#define moI11mwtxiOXpqDxK_aQL mr0l01irlQTHxEjA5eunteQkeoLuBQY(t,.,F,n,z,G,/,S,[,c,n,+,-,l,9,o,i,c,^,j) +#define mVOlbMaOu1U0SC2oeKIzP mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(-,{,B,A,],P,W,-,c,},4,b,7,Q,R,;,!,7,t,I) +#define mCAk2bmH5F7oeetankJLO mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(8,=,^,+,u,j,;,c,y,/,v,2,+,F,G,},6,],8,q) +#define mEMN2sRTwHcTUl7SNSw0d mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(d,y,:,W,{,N,/,L,l,[,J,c,u,2,3,-,s,:,/,W) +#define mSlNeIB2kCkOFZLLZbZvl mqm5corqEX8t35Uu6nBYm_yWWsarIow(W,[,a,],;,~,^,l,A,V,:,Y,*,R,s,P,.,.,!,}) +#define mD8VAS4XY9Vf6fdJqnluZ mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(F,.,3,1,s,B,p,x,-,-,;,r,r,5,/,!,R,=,k,P) +#define mDd5IIsnjfLI1lcygRsW3 maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(0,z,o,i,/,6,C,Y,:,],},W,o,i,X,8,F,h,f,V) +#define mJWlrLOowGXzksrQ1iOpo mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(I,^,7,F,{,Z,o,m,b,e,~,*,],7,[,u,Z,4,G,d) +#define mhnMl9nmNNK1ubSXXRkWs mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(a,H,o,=,;,G,n,p,c,;,D,c,^,[,/,7,T,<,l,0) +#define mE51_Yx1e52Gg6LtJn8Ft mc03ciJcqzEcDCvFZREOoKestkbXulB(a,/,m,a,s,j,g,C,*,1,e,n,c,p,^,[,W,e,-,P) +#define maISPbNJKXWB2QqsuuExM mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(h,D,k,j,T,*,I,r,{,R,f,l,t,*,W,o,p,b,a,.) +#define mU8SToe5QpPWgY0z9QAcm mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(G,o,^,l,b,c,.,K,j,],;,o,K,u,P,o,r,d,I,X) +#define mDx7kMxPPgzO4EUIw_BnI mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(9,3,.,},;,:,p,+,^,c,3,[,=,c,B,G,8,t,^,-) +#define mKpq3GwvJxRduE5RsGgGP () +#define mOymGuaDUIEo4ESm5VpCR mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(-,b,4,=,S,B,D,6,z,/,w,[,O,r,m,/,0,/,:,x) +#define mCvAz6nTbqhvwRULRgKe4 maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(_,^,a,1,F,x,p,I,2,},.,d,6,8,;,0,J,3,a,p) +#define mZk2lUQMDVDhOLQdg9s92 mLsmsKBxetQnHulsmKvKGZrZv3OKajL(L,},j,{,o,b,l,0,g,G,:,!,:,q,/,Z,t,:,W,=) +#define myyhXEjkyqbh66A1Qwu0O muRWS4RqXt1RDg1intuX3MkjrSgf2o4(s,i,-,6,r,d,r,-,.,v,w,-,1,4,;,M,{,h,*,-) +#define mGbN63kjoGx6fvYq0oiYN mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(!,i,Z,n,-,K,:,e,5,r,.,.,g,8,f,E,u,N,r,t) +#define mnSkEvR4SbDwQxj23xB1M mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(^,x,c,g,+,u,:,K,y,z,^,!,*,8,[,a,W,F,v,}) +#define mwBOm3LXJ8FMsqTgQKZ6O mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(.,p,d,*,K,D,u,E,4,g,z,h,g,L,-,V,6,>,L,x) +#define mIwaKux_FnDqG9TKWI9sf mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(c,:,+,/,Y,u,;,P,a,Y,q,R,A,Y,7,^,o,.,t,L) +#define mXkfygpbRUCrOfJA4ktlP if( +#define mLhy8e0peljv3075Jx0N4 mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(L,n,e,a,9,k,8,.,P,L,I,Q,},n,},n,9,G,E,w) +#define mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(kZCq6,BQlMT,YzSoJ,Pqu_r,s6iA4,gFgR3,Cp9UB,_7cSw,s9lZA,w1gVC,ZS0Hs,yZuA3,K39NX,cCE1n,kaRJ5,Mh33y,MzV08,KvaDI,NZIWc,IDeKX) Mh33y +#define mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(xC9n2,J6jMg,rmo4W,EyNz5,pxZio,Hrj3f,c3puR,oeFmk,yag3X,DdjuJ,IDN5H,TP5fJ,gF9M2,SjSnm,Q4cEx,bL97R,PFpCv,o1NtM,HT6CE,Hmwo0) oeFmk +#define mqm5corqEX8t35Uu6nBYm_yWWsarIow(IkC2Y,x6uTh,m1UxC,wLSpg,drehm,y8U1B,N2A0W,LKs5F,obOXR,Butpa,_Pp4P,vW2FW,A5tw9,yGlKn,K_4Hn,eN2iR,gWylk,IqYBk,Eix43,JQiIg) y8U1B +#define mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(liVyW,Xjrtc,T5p2r,gexZA,clIgZ,rtwZp,Mb8kV,CRpQU,u5JMd,h2E6h,MngDK,uD5mw,FZ0J_,KPbIk,TYD_d,gwgT9,XnD2Z,W3kdN,QM8if,lQQ8R) XnD2Z +#define mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(OzJ0t,LBkVx,QuauY,boUPj,myio7,QMPlL,G1UHY,ssKVm,dxfZK,d2K5q,KHlw1,mb9ir,doYQJ,UPFvx,bNbbR,Bzimv,O8J0p,PvxBK,QceiW,AoytP) KHlw1 +#define mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(IlPHJ,ZfftO,YW__p,a7bmT,jU6MN,UZc5s,kVXnM,rmQOm,o8MZv,iMISj,DPDtU,ScZJN,fohfA,VAaGk,f5qNY,apwDj,qT0sn,a1AUg,MaWUp,gsKnD) jU6MN +#define mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(H9l1s,sSiEG,cGR6i,QtZEf,ApdIo,Wayla,qpIU4,jco9j,l4OlK,LVs8o,FnDwW,OKe3q,VVJOd,Pp6Hb,Z6vAD,pBS28,DuISw,QWdRu,jm4X3,vMlqX) vMlqX +#define mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(unCi6,Qomo2,MbDiY,fjddY,sA2I_,KWLRE,k4GJt,kAtwt,Ay9vb,z5ryO,SdKs3,Tbcat,bbfiX,YpUIi,ad9pa,b68_x,HHm7q,KfFHN,sWaHp,LntSd) sWaHp +#define myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(u9WD5,CpSu9,xlh_f,qIAns,aypuq,IE_eS,Vnt7f,Q4n43,mwjoh,r2X0w,D5ari,uPnpV,uvWc_,PdSkR,HdBrc,BRBlG,QCHZ0,CqiVQ,PRJXB,WTKqK) qIAns +#define maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(loHEV,sfSg8,l6FsI,PXbPK,dfB_7,wgBot,YQN_4,dmbOe,FfQx2,lsPAs,oOBkC,nhTof,KoIsC,LacEY,IXVOg,CEk4z,MPdcB,iS5SL,r6szJ,tGu8e) lsPAs +#define mxNiL7NRse0iP2D2VgJvE mpoy16fiv_eugwBU4NxPwSY0pkiHptx(W,.,Z,M,i,f,t,7,!,u,n,9,i,t,i,s,_,U,3,2) +#define maOczvhF_v9OTsK70ZZut mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(6,t,;,h,Q,V,v,h,Z,o,+,E,f,M,a,},B,v,l,L) +#define mfXSqvRpqFIhzf0yTtohv mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(:,n,5,E,f,7,.,J,H,-,^,y,t,y,.,k,_,},W,B) +#define mJSI8Lfa53eTFnQ8sZxQl muRWS4RqXt1RDg1intuX3MkjrSgf2o4(7,-,l,H,Q,h,!,>,:,z,b,>,D,7,*,L,n,W,h,0) +#define mpHTdkvfapV5_Igrm_XSs mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(X,D,!,D,o,Y,a,W,l,E,1,b,.,+,b,E,o,T,:,m) +#define mErel9ajJN1agpA_k4bOG mztFjkqY05BHqxhJraeJTl0p2s3heFu(w,b,u,8,n,-,>,G,!,w,-,F,e,!,{,{,x,l,j,.) +#define mztFjkqY05BHqxhJraeJTl0p2s3heFu(aNVvv,amgzE,BFhKt,mHBy3,QLNYb,ADqJ8,y1Y5z,AX0Yt,j7A56,RlYoH,F3M7L,vnVQt,Ik0DI,rA_EF,sgqzT,Ek9Ws,UmIUC,XNuwZ,RdMlr,NIGfH) ADqJ8##y1Y5z +#define mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(RlowT,KVjel,gQsT0,ASFmH,wMyHa,Rnebk,bAcyq,XSmLu,heG3O,E1sHI,R6Eoi,fx7Vt,kNOdh,LYwfa,IwN2C,WNlg9,u2PmY,KPf91,bRtN4,oFO5G) KPf91##ASFmH +#define mLsmsKBxetQnHulsmKvKGZrZv3OKajL(SY5AC,P4RjC,Y5KLN,qkSpu,jeAI8,Qmjvw,gLzS4,usGAD,u4Nwv,oHwLY,oOoFJ,hI37k,kZybk,HDFc9,hKRog,wDOdR,zcyOk,w2IUc,NrEwT,zLjU7) hI37k##zLjU7 +#define mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(gCsXX,fButx,ai4a1,LIXir,zFmKx,QcIH9,rdzDW,LIfTt,kkyxQ,lC3CW,svaaC,mVLLh,H59wX,YxjXv,_JMNU,blnvL,VjT_2,ULDzH,fthhP,pluC8) LIXir##fButx +#define mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(BEwtN,gG9pF,_jEtY,lRgcL,x6Ozg,Z35mw,rAhVz,aPfpI,uQgL0,eV6SU,sMqO8,UUyYz,AZK8P,e611Q,uWWAx,LHOog,WV_W3,NXXmf,D21P4,_6yyF) BEwtN##uQgL0 +#define mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(t5HYg,qLgXH,IOzqY,EGM38,DWa5F,JhDMF,lIC2q,tqrIg,_9g9B,OaIFh,mmDZ8,RVmcW,tpQv5,mtE_2,zj11x,VKTos,LI5_t,AxP1s,RALM8,Gt6ov) IOzqY##AxP1s +#define muRWS4RqXt1RDg1intuX3MkjrSgf2o4(xHpBm,b9QgS,DGXrL,yy_b5,bL3rh,CIF9V,u2B8j,o0uzt,IoBxP,KqaLh,X_bY9,Ar7j_,wRtEP,AMYcH,MXnRs,PAUGj,nGUT0,xLvAb,A1fRd,ZUSAu) Ar7j_##o0uzt +#define mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(BURHY,d5n8W,oWfaP,ERvr9,bqPLd,ZQxih,NocLv,xidzG,HLSQD,FVRWp,w5Twn,YLx2i,W_Ynz,GU9Et,Z_sJW,tVmoQ,strtu,b3ZIr,Gd_Fs,aisT1) Z_sJW##YLx2i +#define mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(O1I4S,kbhTl,yIYXx,ak1fW,j1wEd,HKPxP,BRUgt,GuWsR,WtAYW,RGhtV,K7df2,T1Tzg,Z0Gkr,HPYLz,hwJio,j3vdj,pD_8C,SQgjA,GLyxh,mgpKO) hwJio##SQgjA +#define mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(NySOL,fNhIp,EfgoU,M1fNQ,_48Zk,NmJgB,wq1Y7,Y9U5w,bW1cu,ihV1G,DU0hA,G_0MY,cwGh1,KxkeZ,uSHWS,Sq1kX,qsBuC,xOeG3,ZhbCJ,CNZ5u) CNZ5u##cwGh1 +#define minXN1_7si2azFOae4puK mAB2YZQWllAMMhMcSXYQGJ6zEaONDDT(G,!,l,b,:,i,i,S,u,Y,M,c,p,},u,5,9,E,c,c) +#define mbHCSQc_uaLNP9Sf4Lz_n () +#define mkGHGzUDDVqHIjIdYGe6S mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(O,7,+,!,K,R,/,m,N,*,2,1,.,!,m,K,k,+,-,s) +#define mILaQGKCAmcKrYQNhgWUq myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(4,1,],[,[,d,O,q,U,;,+,X,8,],R,[,.,^,/,{) +#define mjVigZhPz5SJG76mcwBBH mJRcV3UxOoHUziTla6CTItAztGL9WSZ(i,e,L,v,i,a,9,I,4,n,t,d,C,5,:,k,j,p,;,r) +#define mKzXNxKoc8d_JaqSCmnt5 mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(F,Y,a,;,],],],G,9,h,u,s,g,q,a,i,*,r,n,J) +#define mUCEzhGWrU8OYqcHVPlVW mztFjkqY05BHqxhJraeJTl0p2s3heFu(-,C,o,!,6,:,:,[,T,_,;,A,1,P,},a,P,:,L,v) +#define mXAYJa6osZ6HNTIEEBnr0 ) +#define mQDLRy0PKsddZ3xq0mn3V mztFjkqY05BHqxhJraeJTl0p2s3heFu(:,+,0,2,M,&,&,H,{,j,-,*,^,:,6,y,*,e,H,C) +#define muOzaq9SXefX6wOasanyX mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(:,K,M,y,K,E,;,L,{,O,p,i,T,5,!,w,I,=,7,t) +#define mj7rzLUFNjZZ8TQ9LzphN mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(],^,w,c,B,R,r,p,q,/,6,K,],t,Z,q,H,g,u,e) +#define mIqkiLoOdpjYrPavNSkO3 mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(!,:,>,.,3,F,:,/,P,t,S,2,c,},C,^,l,>,S,z) +#define mZVOYp2JAGvUM7UPbzd3Q mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(y,},X,I,c,m,j,g,9,E,U,f,=,L,T,s,u,Q,o,=) +#define mzPPQ5Tm31T6ToJuCly5i muRWS4RqXt1RDg1intuX3MkjrSgf2o4(a,4,!,W,^,J,[,=,C,+,:,-,M,P,.,2,^,P,B,]) +#define mPBSejyyYBZX7KoLjIvqq mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(j,G,z,l,d,6,N,+,G,o,f,u,h,T,!,b,O,L,e,8) +#define mXyxJEKR2vQDAiXVkkZ96 if( +#define mFrnvKb629IAbveEQOTJk for( +#define mOR5gj7K3yTraJVOrvmKy mLsmsKBxetQnHulsmKvKGZrZv3OKajL(:,*,p,M,;,Z,n,o,[,d,8,&,/,q,],3,q,S,f,&) +#define mNEkKASvjK_HgII9jzEu6 mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(O,-,*,-,9,d,h,F,8,F,a,[,],.,*,Y,I,;,g,G) +#define mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(adm9Y,Zom1z,dmI_z,lOmG0,RkEKt,AyuH6,T8EWA,zqzuo,ivKZB,mI4sb,F8v2O,OA6ih,gH5uB,GzoBY,ZBEY2,cByOE,ViVVO,mKQpC,D3aUD,QhIgE) ViVVO##AyuH6##dmI_z +#define mshTvqIeJnktjfxvTh_Q17geiWCXNRC(rzcxW,SmEzE,gPJ9h,nSmcC,RdKza,ZnwBk,HsD9p,iApSK,E4_Xf,MWnoW,P4BiE,n9lNJ,qSmdv,ugA8B,ZhL8T,XEvgv,m4IKR,gE3fs,q0dwA,mTU5a) qSmdv##rzcxW##q0dwA +#define mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(osiKi,l0nhs,opQqU,XUWw9,JKkom,WBokW,ITUXA,dW9TK,xa7PW,FvcNh,PjX5T,dDV3l,CpAYI,G96JX,w9UBX,Mpt4u,wTaaW,Zv9OU,agay_,aZI1j) Mpt4u##CpAYI##dW9TK +#define mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(B3KLb,lg1LT,WXBrv,KfsTP,rKnQo,GjMW3,NOdZi,OFcW4,pgBQ7,YpuLD,CPO1w,ZSpa_,mMlHs,gQV0s,PQQVm,bP4YQ,wPRo_,lfl4x,ym2Nl,tLJQp) ym2Nl##B3KLb##rKnQo +#define mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(ehZq1,qgLEA,EfxKf,PA0H_,CUiHk,LaV0Q,bFCAU,VC31X,basrq,xFNyX,wxgIz,NmJzv,tzzPz,Rr5xi,OyBAw,pgewx,PkNHj,r4G1S,BX5fT,yHilQ) yHilQ##LaV0Q##BX5fT +#define mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(X9HuO,qwJzv,MXdkj,aSo12,gVEcs,shkHc,P93V6,svVQd,PzfT1,M3Dpg,jgm8y,z9WKg,uTXmv,TaAc1,JaEXP,ZoaNx,lDgFY,DprPb,zaKlB,NXw92) lDgFY##DprPb##X9HuO +#define mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(gTGgS,lwtrV,_hAwx,I_yl2,ayFhC,gHM8w,L7kdz,BZwGT,Wwt7f,Ast7X,IRLOY,_INwu,m_v6E,ZOIsX,hRpdY,UZk2y,ZAbh4,FFSwM,TL6aB,pw4KY) ZOIsX##_hAwx##pw4KY +#define mr0l01irlQTHxEjA5eunteQkeoLuBQY(YC3fg,Q5OI3,xHBzo,YtjlJ,G2ue1,hX_hC,JVkmo,li3ff,vOkC9,Aj54O,R1dqi,c5JEq,pIo6w,gPria,Tlloq,ig8VW,o0vdF,CI1YO,nKOs2,mlicY) o0vdF##YtjlJ##YC3fg +#define mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(TZJYZ,aJOub,sIVAx,Pr1Nb,PvZLM,Bug9Q,XqVYi,EnOLx,OtBjG,NQhwk,Scwgk,fuAMQ,kHdsd,bLUO2,vP8pJ,QKUl0,ss7FF,_gojY,Zjkn7,RGBf5) TZJYZ##QKUl0##Zjkn7 +#define mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G(O4Il5,cKXDg,BymNy,dfBDP,lGgfw,fmxTV,VfLpt,Vh0K3,cCd6Q,gXHOA,SNzDr,L87aw,GUfdn,FksBq,bYpVw,yCOfO,kdLDB,WqmqR,M1IOE,URfVv) dfBDP##SNzDr##M1IOE +#define mWokjWH0MHqyBOx4j0Oac mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(t,/,R,m,f,Y,O,a,o,q,/,L,N,/,],i,;,O,l,u) +#define mKwBF6wdaXmwZg6eVpHR2 mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(J,H,N,2,u,:,2,o,e,F,r,J,M,b,t,[,r,P,4,j) +#define mNHO_HqPPuJ0s1xmA3Hyp mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(k,:,U,3,b,[,R,a,e,m,.,1,^,Z,K,V,],f,r,i) +#define mbVacJ38Njfe_9kvqyl6v maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(},O,0,t,Y,7,5,1,],~,i,M,[,n,t,e,b,o,N,3) +#define mEs6URNF5M0ltIuqxZLOvZ6JUSiM86Q(q3EZy,wgjKa,ictIO,uudO3,jd9Mc,eWAZ5,sGlrb,lxyAG,sdFt1,ECvrX,wq25O,YWPxN,FfxFr,Y6pp0,Bi0_X,GSNXX,XjI2g,yyIzE,JoHxb,zgzme) Bi0_X##FfxFr##XjI2g##uudO3##zgzme##sGlrb##q3EZy##yyIzE##wgjKa +#define mexiex6yQ4W2cwOKYmh9Kok982mCBo0(XJ25j,uqlLZ,KTTa2,jwM3F,XxAd3,Eftdm,S4RoQ,i0StZ,HWQ0Y,W2c_h,SHKTt,tw9Wl,oAZz3,Rkesl,qbE5b,KB93e,LjyIE,VksOh,N8e9_,pVyYc) XxAd3##oAZz3##SHKTt##XJ25j##Rkesl##LjyIE##KB93e##KTTa2##HWQ0Y +#define mjE2s1jSu76TqssWv5OkpQyTNcXDW0j(Qwxzr,HH4RJ,yg0vT,cmVov,ohs0V,AonBl,sgsJ8,iVrzO,AR2DD,P2gj1,LGxJS,NePoy,yw_mw,nco5r,ug3jN,XwLoF,L9Qvw,otJRf,Kitap,wsOgZ) P2gj1##yw_mw##AonBl##ug3jN##Qwxzr##nco5r##LGxJS##yg0vT##ohs0V +#define mmu72Hys1y28eLiXc2AAu_ewAGX_SGw(Nwk7y,DqahH,wAwQE,a4k8W,B2JF1,bJyfP,t_njf,QAD4b,wmU7t,Ob1Vp,ZmKXP,FZiCG,ZPYSU,LrsOx,jBKOf,tEvmk,nCtCN,sea65,g_u6N,Ok1B8) wmU7t##bJyfP##ZmKXP##a4k8W##QAD4b##LrsOx##DqahH##jBKOf##wAwQE +#define mc03ciJcqzEcDCvFZREOoKestkbXulB(PqnD5,S7i7E,fys40,xt0vn,ULCcc,znx40,c78WF,WiJhn,m29my,t7H9l,D2fB7,QwnJR,_Gjyz,lkaRU,_PdfZ,NoPCy,C8PgQ,E66P2,TJoVj,v6hdm) QwnJR##xt0vn##fys40##E66P2##ULCcc##lkaRU##PqnD5##_Gjyz##D2fB7 +#define mlkXvCGjzNE_N7vszwePKcZNchffiZF(jACSu,gkVGM,lHw0i,CUT2M,Extii,tZE31,U3t2K,gnUgo,OCfJG,E1yWi,_ZDoc,TBIoC,LzPVd,kSPJk,gPgGu,jUx7I,FEle0,A1weX,jB_BU,Jl6V0) gPgGu##FEle0##_ZDoc##tZE31##gkVGM##Extii##TBIoC##LzPVd##E1yWi +#define maZplRnE_IUwmU_xzu3NekpUHRmaUSP(byp99,C8R66,v_eDw,WHuBd,aJBZr,I7MeH,P9d8G,OViZi,mJslV,YMoQx,LmmAP,T7BGE,s9xfk,TZx8I,cYoRx,nmWsv,VZ12q,kqPQT,zkf1u,UXVHy) kqPQT##LmmAP##cYoRx##I7MeH##s9xfk##v_eDw##OViZi##C8R66##WHuBd +#define mwuimZUNEQYuguDYpIp15llEoOqkXc0(kyTxP,HNYfJ,GJD9B,Sr2KJ,N3uFU,rhHJe,Ip33S,xcgYk,ZGivZ,XK35Z,DPDgk,tHgPL,IgjSC,G4j__,IBc3I,ahZpL,CjZM6,ItXBL,geoLe,IfyCh) kyTxP##GJD9B##CjZM6##tHgPL##G4j__##ZGivZ##IgjSC##Sr2KJ##XK35Z +#define mf4h8kYb28ybDtqub3aw3HtQXgCqXKS(Hv7mU,nh0hc,eoEQ6,NAmCO,ECJ6n,spFec,PkQDR,_0n6R,wr3t1,Vbdoi,DCGMp,Y1ZVF,N70IE,FMICF,fiuGW,gdnxz,m2eNY,N30PK,fTc9f,dIZMY) Y1ZVF##N30PK##wr3t1##gdnxz##N70IE##eoEQ6##fTc9f##fiuGW##_0n6R +#define mQaMmAoZTrzB9rh95SV_SNzHqc0isDC(iXJUH,uJy_t,Ok3Sm,hpuFF,EQIRl,t4HMX,cbr9Z,dQTNt,VH2vV,lPfes,fuTgG,zSa3a,DwYGK,aLhUE,lddPH,ggNGK,rZ5pb,iObUd,V5Dca,JK4Qk) aLhUE##rZ5pb##VH2vV##fuTgG##dQTNt##lddPH##EQIRl##zSa3a##hpuFF +#define mbtXL8AfsmYGQ1waevjwS mwcRCcU6S0ahJKT269YrZSchpTbqC8A(n,*,-,K,L,_,t,i,b,C,t,3,t,2,B,x,-,u,p,U) +#define mGkUuomrp7ufvC8H_J8ZB mr0l01irlQTHxEjA5eunteQkeoLuBQY(w,{,w,e,x,K,8,},v,Y,f,W,4,x,P,;,n,O,i,*) +#define mp3H4249LtCVDCYFqQqz4 ( +#define mtvEQgcnwdOR4zAMwLHDb mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(a,_,v,B,H,o,3,M,!,+,;,5,!,_,_,+,:,M,r,f) +#define mEZrtAN7pSZl5y4oEHd38 muRWS4RqXt1RDg1intuX3MkjrSgf2o4([,{,_,],a,g,N,+,v,],L,+,_,B,d,8,0,i,],S) +#define mKmIjE1RujJ5RSETUjqwW mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(A,.,-,Y,i,X,.,N,v,d,R,R,0,z,0,A,;,9,o,^) +#define mopvqiLosQusnLb5T1cPQ mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(t,k,9,1,!,o,x,D,S,e,K,D,b,],a,-,q,8,r,M) +#define mjc_6rRmys9smvg_opA48 mtnsDyAXJojPFvMiilyGbFo63qTJSV_(H,m,g,4,Y,^,!,p,],x,o,.,H,u,t,a,0,t,^,N) +#define mnswinmeXuam57kXH7myI mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(5,-,K,],l,{,R,V,J,r,!,.,o,*,V,!,Y,6,3,-) +#define mLEx8V9d9KOGX6TpfxDP_ mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(u,e,5,t,S,K,[,L,Z,l,c,s,f,w,s,+,d,{,a,/) +#define mKqJbq4fPTw28Ilr7bzpA mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(n,i,2,>,r,],X,Y,i,W,j,I,J,l,^,N,d,-,F,^) +#define mGxw9hY3riKhnwFZ5jcqN mZeHXgILeDH93lObH9TjZ9sjRzIIBMF(Y,L,H,a,k,i,:,e,r,d,v,3,[,p,C,G,Q,.,G,t) +#define mdWkXjuaPd4Se0r0SdY1e () +#define mHOvg7vOJH6ujsVsg3S5G mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(y,=,X,=,R,6,Z,0,/,_,w,i,Y,!,2,[,[,!,-,n) +#define miAr40ThvnnZei4PQ8nft mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(4,6,q,|,/,[,P,n,Z,A,e,g,i,+,/,*,{,|,S,2) +#define msFQPbyubcQTkvTYpFFPL mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(},U,7,7,1,S,b,f,+,0,V,0,I,Z,*,2,!,X,l,V) +#define md8eYFrUH5ZCVnYz5HXJs mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr({,q,4,l,e,Q,k,O,q,G,o,-,Y,c,b,:,P,u,d,[) +#define mrYTPN06XEG4I2Q8GwVal m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(e,e,o,+,k,L,C,A,t,r,R,u,J,+,9,U,S,1,o,T) +#define maHkatHu0Jap4oTaT5q4_ () +#define mqwYu0y4oTPCnfXbylThX mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(],s,;,e,G,W,w,o,0,d,S,;,},/,[,C,b,.,l,u) +#define mhDkJpX31vSJRGCWwJgDF mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(S,t,b,:,C,l,^,+,9,r,L,j,2,e,},-,k,y,A,a) +#define mBJ7M0ikk98KhD4Oi32wB mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(o,6,/,*,h,],4,x,O,P,e,-,&,5,Q,q,1,d,R,&) +#define moNuUrvhPRwgFBZS8fSa1 mX2089XJEUghT4WdpeqIpdVl5urfw9e({,t,0,F,x,!,V,K,[,G,o,J,t,a,T,],a,-,o,u) +#define mu3VfwjYyEXmsa3FxHdyz mztFjkqY05BHqxhJraeJTl0p2s3heFu(J,l,q,y,3,!,=,{,],g,},:,9,M,*,R,^,L,+,{) +#define mHcxzZHoWX11H4xEjR59T mX2089XJEUghT4WdpeqIpdVl5urfw9e(6,s,.,Y,8,6,s,^,f,+,e,c,m,.,2,;,e,*,^,l) +#define mt0GBkUzL9v7leCB9JJCC mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(o,4,N,=,C,f,c,x,Q,/,+,q,x,1,B,w,;,*,t,L) +#define mHaUGkpJ3E2hPS8TahoVd mLC2F6mTDlCPm4Amdj66bcsfP08vka4(r,],m,o,r,K,],o,l,],4,n,],U,b,[,m,*,z,]) +#define mVHGLK1C5RNdKdXzDgMZU if( +#define mwzVPTpaJAiRC6bZKMfQX mshTvqIeJnktjfxvTh_Q17geiWCXNRC(o,;,/,E,4,W,O,/,{,c,^,m,f,^,t,h,!,I,r,:) +#define moE42zHNBVjnlCdllZAkS mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(a,H,b,2,7,!,J,9,h,V,u,;,=,2,K,m,*,E,+,>) +#define myo_tabD5NOdQw_HDUeAl mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(;,e,l,p,o,y,[,5,r,T,1,f,5,.,s,E,7,x,+,a) +#define miAECMSxGwjxrcOKk0DII ( +#define mY2nz8M_6jpSxQZL8EYgU mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(K,*,^,S,v,1,x,],[,a,[,*,b,u,P,j,C,D,Y,{) +#define meWm4MhzbcJwavtoh469w mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(A,{,t,5,S,n,!,!,+,],x,M,],O,.,},i,T,7,i) +#define mbG1GEmOdh2dXkJZ42sXo mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(2,Z,[,[,.,3,e,H,a,u,<,I,a,8,e,-,0,:,g,*) +#define mpi20hzA7RnQ_cRlycwva mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(},Z,!,Y,9,y,*,[,q,p,!,/,i,G,U,d,W,=,:,4) +#define mINcNsH05D0QZDej9wl4h maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(N,6,8,+,v,w,l,1,-,;,J,V,r,M,D,*,n,8,],h) +#define mqHOA0Vf8azkugKZoQT2g mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(g,O,C,E,y,_,E,~,a,{,{,m,t,W,8,O,5,Q,E,Q) +#endif +#ifndef _3643599497981880515 +#define muh3toWhBpay0OfyCHmRI m_7GcuKeh99wm21PzmE3XY0ABoZNB_w(9,X,w,2,_,S,*,:,:,w,h,3,!,t,i,8,t,n,u,2) +#define mCBPKKFCRSbvDkZsS_B45 mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(!,k,e,-,9,],z,U,/,v,^,b,H,Y,a,I,Z,M,!,r) +#define maSZLm7xL0jGtxyrdwaul mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(W,A,z,z,_,.,*,7,C,v,z,u,t,:,v,R,~,.,+,u) +#define mmB6x9VkGrq_qpFtMKL7A mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(t,5,{,r,O,E,t,7,7,w,},/,:,c,+,s,u,/,v,:) +#define mriCvhMavpfheoLNc0eCD mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(_,U,a,X,;,j,d,c,+,N,{,+,m,i,h,I,],[,k,q) +#define ma6VjqdfajK4BX9gkoGiD mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(T,2,y,.,G,[,a,l,s,D,4,Z,q,H,W,=,:,+,x,S) +#define m_Bc574zvmsa5bmM8Ay7H mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(z,-,n,t,^,U,t,g,:,+,E,M,c,H,6,9,P,Q,-,L) +#define mtDHooAMb6ubWraYLa7pj mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(:,P,-,],t,:,U,!,-,J,A,L,=,i,k,Z,-,A,7,!) +#define mgor9wB6mrVARR8vJt7rC mLC2F6mTDlCPm4Amdj66bcsfP08vka4(4,q,E,r,_,-,{,u,e,7,O,Y,N,[,t,+,5,R,B,0) +#define mRltbJjpZ8AzImbP6r6M4 mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(W,+,U,1,{,X,p,g,F,^,!,^,:,X,b,J,W,w,e,O) +#define mabeHDqoCFUg5Mty5oLni mztFjkqY05BHqxhJraeJTl0p2s3heFu(},J,*,2,3,i,f,y,R,[,d,Z,L,3,c,s,L,R,J,a) +#define m_BNZbnU2Y1bOBnnPOF0b mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(o,V,.,G,r,[,4,N,:,r,P,U,:,},^,i,w,3,f,g) +#define maCQ9r5fSln_CXgRXGFvO mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(D,b,s,v,S,g,^,^,.,+,},3,C,{,.,U,L,7,P,C) +#define mu5MgGYXZDetF61l00p1M m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(d,J,T,C,3,.,7,5,v,o,-,i,O,9,!,*,*,-,X,g) +#define mGyGrvv4NjvJFmxY5zFqS mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(C,*,Z,],s,F,X,o,:,_,i,w,C,/,>,[,t,>,t,Y) +#define mxMl9vPEiIZkGZuxtm_RI m_Gim03zcA2esaeteCftKMhV2X3oFiR(V,/,*,b,c,8,T,:,/,p,a,i,^,H,^,c,l,b,u,x) +#define mYfpOohym5jydVBxgDUop mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(z,W,N,/,D,j,r,k,N,t,5,>,a,h,>,j,h,^,Y,V) +#define mRawsH1LNxMcHXhyroWR7 mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(5,;,4,c,j,4,4,E,},m,l,^,|,I,F,!,L,1,C,|) +#define mo03bPDhF7WKTf8ndM1Bk m_bMsemALspVgRNyYoh4QNv5h7J6TCa(U,J,F,7,I,d,9,h,u,/,.,r,9,r,n,e,a,V,.,t) +#define mH1xQMRmYb0Y4RDp2hARz () +#define mHgo4JTEAdFhAHz3buc5U mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(},=,q,!,-,L,/,A,s,],U,T,b,+,m,K,-,{,w,{) +#define mSa4WnWih0z4lSo9RYUGU ( +#define mT1nRBXOOPTe1uInaQg48 mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(-,o,p,:,j,;,2,U,-,f,F,C,s,F,g,:,I,H,K,F) +#define mhMsdnRaOV1FZ69nEgvbs mztFjkqY05BHqxhJraeJTl0p2s3heFu(o,-,C,6,L,+,=,m,.,F,T,[,d,/,C,x,d,T,w,X) +#define mdNWJa6f_e7wadzG60ejq mqm5corqEX8t35Uu6nBYm_yWWsarIow(P,x,D,d,-,^,7,],c,;,W,6,s,:,o,U,:,i,p,_) +#define mGXmXMs8LhHsVpd3vA7qq mLsmsKBxetQnHulsmKvKGZrZv3OKajL(Z,!,k,G,},/,v,H,J,e,K,-,5,r,F,O,a,k,4,>) +#define mWkGo8xUdRIKgJ1DEUvvn maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(D,Y,w,!,{,u,.,j,p,[,.,[,7,t,u,!,N,;,!,w) +#define mSuHweZ8NLqp3TniIO9nc if( +#define mr45_AiDx2WPxM5kKJ73c mLsmsKBxetQnHulsmKvKGZrZv3OKajL(},M,u,.,-,T,L,N,-,Y,*,>,+,3,Z,;,^,7,d,=) +#define mSQwieae_zm87QxGSkqhw mVuIjgANzXjC9nUwtjYpEMMKzGy7cEj(l,v,T,G,^,5,6,:,c,b,/,p,X,u,p,i,],U,S,u) +#define mqQspPZKCoa6LP0Jj0qH2 mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(!,Q,[,+,:,1,T,e,u,l,L,6,J,r,t,u,^,z,N,y) +#define mnqZGwZqTTi1dekKxujAE mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(P,a,z,m,f,^,o,;,j,F,X,C,l,1,*,Y,d,N,+,t) +#define mQwlYb2fiOk1ogUVAZU22 m_7GcuKeh99wm21PzmE3XY0ABoZNB_w(t,b,},t,e,i,},!,s,V,o,a,^,:,r,W,v,i,p,G) +#define mEGd5SkTeDLeSnWPvzGk3 mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(>,U,[,{,G,y,u,f,=,t,^,H,x,*,[,Q,Q,-,l,2) +#define mIYvQtGxrUTK9jCV0wgjB muRWS4RqXt1RDg1intuX3MkjrSgf2o4(],r,I,B,4,z,[,=,^,[,H,/,S,A,M,6,m,r,t,B) +#define mLdYY4X2b7VOjtTSnd7Hj mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(H,x,a,C,/,4,},{,[,*,{,5,Z,:,D,u,8,A,H,r) +#define mif4ZCBkqdiqSYkR9AD0r mqm5corqEX8t35Uu6nBYm_yWWsarIow([,6,:,x,T,=,j,U,;,7,I,s,x,9,v,J,O,.,-,.) +#define mlqM0snvYcrWCw2_QjhQi ) +#define mLBxgVrVeq7bTUcDGJqNH mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(C,_,o,V,Y,r,1,h,},R,-,*,J,f,+,:,1,A,P,r) +#define maDn6NcmB5JPmBvJglMEd mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(M,f,^,j,Z,h,*,R,{,+,a,:,c,k,=,-,P,=,R,v) +#define mC854TxsErP91YgtWBjLs mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(*,-,*,_,*,*,n,I,{,8,X,t,=,+,v,I,f,/,T,/) +#define mqENAtmVRtspFcCyFxQkl mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(A,:,x,W,S,2,z,s,l,s,n,*,>,M,^,-,N,6,.,-) +#define mn7NaVKR8Eys8MRznQhqq mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(6,n,c,N,u,P,i,D,F,o,Z,v,s,Z,8,f,-,d,:,g) +#define mW1YUos9eL_9NmgJuSDH7 mA7GovY8jPZMrXdPcttrfcvZCc5QYs1([,X,q,+,6,:,4,r,I,K,j,!,M,.,;,;,/,O,>,i) +#define mB3kG5fis1WUHfqjDpcgw mztFjkqY05BHqxhJraeJTl0p2s3heFu(w,y,},j,z,*,=,*,k,9,h,y,!,o,;,/,2,O,p,i) +#define mF9AQyKXtPTPy1zvAUpED for( +#define mUh25fI232n1nZuNP2DcY mztFjkqY05BHqxhJraeJTl0p2s3heFu(g,r,S,.,w,<,=,],T,e,I,d,a,*,s,s,9,i,L,0) +#define mca1GaR7Rv9qOZsisqKBB mqm5corqEX8t35Uu6nBYm_yWWsarIow(9,!,k,*,},<,u,r,[,+,V,5,w,b,7,P,^,O,8,;) +#define mDjDVHrQ1nua2LsKX9HSc mJRcV3UxOoHUziTla6CTItAztGL9WSZ(n,_,4,t,7,3,3,Y,^,Y,2,r,s,h,t,B,C,u,l,i) +#define mbndM1iNeSBZryqPzzxpU mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(5,C,},B,},I,8,f,3,U,.,d,5,H,-,1,^,h,{,x) +#define mN1cOqoznikSSj4MMYyFX mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(e,{,/,O,^,4,Q,7,o,],C,6,A,B,d,K,q,=,M,!) +#define mMXwD61a3ZsfucFBja1D_ mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(-,Y,J,7,],C,Q,i,:,H,;,Z,=,:,;,Y,R,t,M,<) +#define mtFjgCt4NTpjOcEST1puq mX2089XJEUghT4WdpeqIpdVl5urfw9e(c,o,q,S,1,N,F,f,g,o,l,R,7,+,],L,b,I,O,o) +#define mt3VEObKOLfcodk2q6Hb4 meSFhtslMYeRECKXZrMQ8rKH8kdvfsC(L,_,8,r,a,Y,v,i,q,t,e,B,f,G,},},.,F,:,p) +#define mYwsOAvDOXneTzOST0d5c mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF({,},_,!,*,i,m,u,[,.,X,M,w,f,+,X,;,=,T,r) +#define mwQUfI7G4pBH6IJQiBjmU mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(t,U,i,m,N,_,b,n,x,/,o,f,6,m,a,J,n,f,a,f) +#define mYM4ze6K0DiGvfExY0uu0 mwuimZUNEQYuguDYpIp15llEoOqkXc0(n,{,a,c,4,k,z,Y,p,e,9,e,a,s,I,S,m,d,r,h) +#define mcJvl68QD2UYT9DPOREOj mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(l,0,r,<,/,^,;,x,G,0,v,g,{,Y,A,i,:,<,+,+) +#define mBpPKNB5wfuTOV223BA2r mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(:,/,y,R,>,Z,M,!,[,m,E,j,r,u,{,x,[,Z,c,4) +#define mSBH4REv5nn8iXIXWLqFa mElbPhFy9PzMYpwK0rJM72HTzRPloIw(H,l,e,d,u,d,[,E,;,[,u,.,M,;,4,B,b,O,o,k) +#define mvAxy99EwaX0EkXFRf6SN m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(o,V,p,q,-,y,.,:,a,u,G,t,[,{,q,S,d,G,6,x) +#define mRzhpvoeHZK7yCqqzYDDp mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(:,a,Y,f,{,0,j,a,K,F,-,5,.,S,6,O,i,i,R,^) +#define mNAgAegAkh3aostDDex0p mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(-,Y,4,w,1,e,v,Y,W,t,+,T,!,;,*,E,G,Q,w,n) +#define mifrRvzkyTJgS5ZnlEWNT mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(L,6,Z,;,W,G,A,L,l,[,!,X,L,E,<,Y,8,<,d,A) +#define miFyHzo07syL8tsy3JLAT mElbPhFy9PzMYpwK0rJM72HTzRPloIw(8,r,n,k,t,r,K,F,1,g,-,^,;,U,F,O,u,n,e,.) +#define mglDNKH5ah89GptW6H4Cu mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(;,t,o,g,^,d,[,d,^,u,x,f,2,a,a,B,-,G,/,l) +#define mb_mniVMqcXJMFkJcXnTV if( +#define mHXoMWKZSiZYUvqmVkLF5 mLC2F6mTDlCPm4Amdj66bcsfP08vka4(d,j,R,u,J,U,m,t,o,n,k,k,:,J,a,F,F,n,N,1) +#define mc6SGgM2Uzvo_wy5KTima mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(.,],Z,P,/,n,o,D,P,e,p,8,d,v,A,q,A,/,i,d) +#define mlJqcdUT0sl1_64qaqDwc mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr(-,.,{,r,n,i,[,[,v,e,e,Q,z,1,u,8,r,t,r,I) +#define mgWtxscBTuWBkK7X3fJ_M mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(>,U,R,7,[,W,r,O,>,f,],q,u,*,I,^,A,!,9,Z) +#define mnAk2iR9Su1JlXNU__70t mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(e,Y,R,{,w,u,b,g,g,N,z,e,8,h,X,I,.,A,n,;) +#define mGmn6AwhPqDzvkxFmEeXf mYYWXe0GsOK9y3tuaI0XM8wApbmutU0([,},j,=,o,O,[,Z,3,F,/,.,f,q,{,Z,R,-,y,3) +#define mICILgDpdCTDSJqQAn06L mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(-,O,;,k,X,],*,N,a,6,o,r,W,:,6,},i,e,W,-) +#define mCAzyIDtopeLXRxFfI0EK mtnsDyAXJojPFvMiilyGbFo63qTJSV_(^,Y,e,.,i,:,E,k,u,-,e,5,s,r,S,t,r,u,O,h) +#define mDWRa2VXHJyGtXnU3Z9De mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(/,1,],B,^,s,+,S,L,a,K,.,>,[,*,l,5,Y,:,>) +#define mwkUVn0D8pUxgFq_rx20G for( +#define msRrpu3bfxgN_CQlh5kGb mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN(2,t,i,t,_,-,P,i,p,+,y,A,u,n,v,5,3,T,b,W) +#define mUq8qfNXjDE9FPlMHvjf4 mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(C,9,Y,K,z,f,:,_,s,-,y,p,F,M,+,/,G,+,c,Z) +#define mnkTvEdpCXelpIHLLqQno mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(G,^,d,:,s,e,g,:,e,e,;,e,],V,5,6,j,t,l,w) +#define mYsjCP2nXqW2Jls3JAUkc mztFjkqY05BHqxhJraeJTl0p2s3heFu(U,k,V,9,5,=,=,G,8,E,f,{,^,D,i,h,w,p,M,:) +#define mKdH1o6rFuMJ1Fl0PA_sn mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(Q,O,:,e,{,+,*,b,k,.,E,&,0,u,&,-,c,q,/,K) +#define mwu5s8ye7pYEdPIYXjU5h mX2089XJEUghT4WdpeqIpdVl5urfw9e(R,i,3,8,F,W,h,R,X,9,d,y,v,7,B,n,v,1,x,o) +#define mnt0Yxwh2kXjuvEydiY6Z mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(^,>,q,-,a,[,J,/,F,+,t,5,H,M,M,s,5,W,*,n) +#define mA9OyoOle98msK0BnFc8I mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(f,M,G,+,0,Q,6,9,W,m,1,*,:,A,D,o,-,N,r,n) +#define maB_pNl4zuODt3oqXg9EB mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G(W,L,l,f,a,!,j,*,3,S,o,u,],H,^,x,J,q,r,*) +#define mFlVjO0mLpwnCN5a1Quio ( +#define mypSy3lS4LRIjRYTxVxzg maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(-,},[,l,/,L,j,;,G,{,-,{,b,V,8,^,Z,t,O,C) +#define mwnRQJQKy9VbzznJbM76_ mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(q,7,h,},U,:,k,^,z,w,5,=,L,;,/,7,R,/,j,6) +#define myqrAJLu9GRcs5sFEN1xM mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(A,G,P,;,d,b,4,d,i,0,u,*,[,o,v,u,:,V,q,H) +#define mhyL_M5gnmQzwyHW45MdA ) +#define ms9iveRK8Fk_QtPMDvDcP for( +#define mYfYoOWdsOLTDCIBT7npX mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(C,G,{,b,/,B,i,n,^,],6,N,*,e,L,v,O,e,j,<) +#define mndAbF8Mhqs6wYK8Ew3E6 mUPTRsc2WCtijDSKQungDsRrIFUGnz1(u,e,e,d,d,k,b,l,o,k,n,/,o,E,*,L,M,v,l,a) +#define mAQWugjGggd1dm4Esoytv mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(;,5,G,d,v,;,+,.,b,A,A,o,^,l,M,i,B,B,_,s) +#define mQu7TMP4YfBcqf0WCzN18 mshTvqIeJnktjfxvTh_Q17geiWCXNRC(e,9,!,Q,*,.,W,K,S,r,],],n,U,!,2,;,-,w,5) +#define mNhNSN2gx5KERe8tfdmgu mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(i,/,{,i,Y,X,A,b,f,:,d,7,e,x,+,.,[,3,a,9) +#define mdmuaUz9iCkCckSUhcEv1 myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(l,_,H,;,R,!,X,d,^,[,5,h,u,Z,o,R,W,A,K,b) +#define mVVBTZX2L35xKLlbqB8u4 for( +#define mI_QuD605u2H3qQFyuTju mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(/,8,g,D,d,a,l,x,9,E,;,B,o,+,t,A,f,^,P,7) +#define mrzvE9vOXIlwaUYsJynGX mjE2s1jSu76TqssWv5OkpQyTNcXDW0j(s,x,c,k,e,m,!,B,w,n,a,O,a,p,e,W,*,9,l,K) +#define mUB1yrSrKOwldqxmCatN2 mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(^,e,/,n,],:,h,Z,s,],],;,u,R,v,6,0,P,n,v) +#define mMGij61UZUIIYyztVz9vN mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(t,],B,M,5,2,L,o,!,{,f,N,],0,e,.,i,n,-,T) +#define mYI2nkSxgJHf1pY1PttV1 mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(1,r,T,j,2,.,z,<,T,},a,;,L,b,},E,q,],l,2) +#define mKqJtaKtNNFCDA9awnods mtnsDyAXJojPFvMiilyGbFo63qTJSV_(;,n,:,7,R,C,N,J,k,-,d,J,y,o,w,v,-,i,g,C) +#define myYaYWcsrnLoe6SxorDYt mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(D,H,[,r,r,a,;,H,*,e,-,t,o,3,G,u,o,H,n,V) +#define mIM7YEc9Ba5XWDEr0m2YG mRpzyAUUkieNHbskgKP0AofElml4apw(1,l,h,B,G,s,c,a,T,6,R,^,b,p,s,L,9,T,.,!) +#define mZQqomBcB_Prq89ftbAiD mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(+,^,!,O,N,6,4,e,s,},d,f,t,l,e,_,_,X,+,z) +#define mG9O2bX6GrjZ7A14g4o0R mbsrpR8qe_bXg_8iiy7_QWHFwDBK3Ps(l,b,f,O,:,p,c,W,*,],*,5,r,f,*,i,K,G,u,;) +#define mTQiPILYbCv0nYwQtndF8 myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(t,N,6,^,T,d,W,B,N,o,p,N,z,^,t,q,2,6,x,-) +#define miTVnDZI0mihWq9STK4vZ mLsmsKBxetQnHulsmKvKGZrZv3OKajL(O,t,O,!,F,S,D,W,D,7,/,/,K,[,h,s,p,x,{,=) +#define mv4kxLDTrK8Y14srOeMs9 mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(s,.,i,h,c,s,{,s,a,N,N,^,Z,Z,.,!,F,H,l,p) +#define mfurntceIvF3j4__Qp6L5 mevyCL_5kjUx7NbD67ju0rSs5KRucsR(r,c,r,u,b,J,C,Y,u,2,t,g,i,t,H,5,s,n,+,r) +#define mq_LX9xWjqEZjC_8nIQQB mMinTurqhjOTBoJcyTuRpllwDXFTRab(p,v,B,b,4,l,Y,i,O,c,J,d,J,:,[,W,q,e,u,G) +#define mmhvewuTDMRQuh4yozZj0 mztFjkqY05BHqxhJraeJTl0p2s3heFu(n,/,U,a,-,/,=,W,X,x,Q,.,[,.,u,;,C,!,Q,l) +#define mb7CDbA8OAKKL51zp5Kp2 maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(M,;,{,Z,o,/,:,},:,!,F,a,!,o,.,8,!,l,*,F) +#define mUrLXSL7g29oB1gxfN8O0 mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(V,.,},h,R,n,s,/,5,-,;,;,i,n,g,!,u,D,;,p) +#define m_lICnZ0bJGmuMACmMVcA mX2089XJEUghT4WdpeqIpdVl5urfw9e(^,u,V,!,S,k,-,/,},{,e,G,{,n,J,Q,t,!,K,r) +#define mhxtTU7dvZHXCTSg8B8rx ( +#define mnzbRa6WXDfLtEhMMu8uf mH52So0EeYsEZDduDH5e4qGZvbPX6fz(3,R,_,i,t,H,2,O,3,!,d,:,u,2,/,H,+,d,t,n) +#define mO3OYAsYlFzrizsYt__9m mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(:,a,C,:,b,5,e,K,K,5,1,4,r,Y,G,7,K,T,4,k) +#define mukpDKZCMfw2TrxqBczvn mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(/,[,R,R,0,{,.,K,=,x,-,^,!,n,z,-,1,2,i,G) +#define mlxKATcGFZZXuYzEVZko1 mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(B,[,[,5,K,:,f,!,M,g,4,S,D,:,^,9,u,N,u,}) +#define mDzQQrEx5Ki0C6uDHU2cy myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(/,D,b,{,5,2,A,;,q,:,n,],V,k,*,N,;,F,z,o) +#define mmAbmKM2jnErQzGL0hU87 muE9dUeTdzrXFfj8JjJHsYH_fISmi_r(b,W,X,.,h,_,p,l,p,1,c,*,!,u,i,:,K,:,P,B) +#define mbvotPuLfQMMkHkrWczyy mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(c,I,K,k,s,s,.,D,Q,r,I,I,2,9,a,B,^,l,e,g) +#define mILr1bxfFRdMH70QJkaPL mUPTRsc2WCtijDSKQungDsRrIFUGnz1(r,e,t,s,5,},u,B,v,G,],1,t,-,x,j,{,7,c,}) +#define meOIEIGNtns3N9UkZHp_p mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(!,],l,u,3,/,n,L,l,!,c,l,s,!,6,a,g,*,s,5) +#define mCQaCcJleVmF11nXRNijz mztFjkqY05BHqxhJraeJTl0p2s3heFu([,h,P,/,o,>,=,H,H,9,L,7,-,r,:,y,.,X,T,d) +#define mm2qioZxIvP_11cqVcoVX mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(^,p,x,X,U,5,[,Q,-,{,Z,p,<,N,3,c,N,*,s,<) +#define mqHHu9OC8XdQm9Yh7V7x0 mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(r,},K,O,R,6,i,;,n,B,Q,;,2,W,|,!,V,|,w,L) +#define mxjRBOqzfKYNpief2KWEu mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(S,},<,J,8,1,V,c,Y,^,5,;,:,6,},:,3,<,K,^) +#define mi0dc2wlXgNoHf9VPli9f mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(G,v,I,=,Z,^,j,K,J,g,:,S,O,h,!,Q,B,=,m,5) +#define mZHJfF8VODcHrGq0YEwM_ mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(A,.,W,!,},!,u,l,8,c,{,7,T,a,{,*,-,/,t,o) +#define mPrvhmoEgzU_ThNhPmGUb mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(<,z,_,!,[,-,j,{,<,L,1,I,W,!,B,e,],T,A,p) +#define mij4fDpzx7A1fAEkEKDEN mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(S,5,+,*,Y,P,S,d,m,7,.,m,E,W,>,f,F,=,p,B) +#define migVyykpmr2io3DNlFdHK mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(;,>,d,>,3,^,h,Z,U,M,x,s,*,m,k,4,N,Y,m,s) +#define mK5OxIt23gZzSiTA8trU8 mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(S,/,a,/,P,5,S,-,;,2,R,m,I,.,A,-,0,.,<,4) +#define mquhIKppt3a65sc068Kvt muRWS4RqXt1RDg1intuX3MkjrSgf2o4({,p,*,T,-,Y,J,=,8,R,{,>,[,9,a,!,_,t,l,t) +#define mS2LGTpbZiAMEweak007k mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(Y,=,w,/,j,k,H,G,X,6,f,t,D,b,O,l,x,;,O,c) +#define mSDkw9ayb_9gGdMv3ViWL mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(R,g,i,s,c,.,z,S,p,*,s,u,^,!,n,d,D,b,G,s) +#define mIyKKzozGjE84ROdV4z79 meSFhtslMYeRECKXZrMQ8rKH8kdvfsC(t,Z,Q,i,3,E,t,n,^,2,_,;,.,5,Q,x,^,v,t,u) +#define mKcyQhGKewGQ8D80ltPKd mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(t,t,e,g,k,u,N,c,j,^,U,{,s,:,E,V,R,{,r,]) +#define mLplHCs9IECRrk3AL90fE mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(Z,8,p,*,!,:,D,H,k,c,G,S,;,p,o,Q,f,*,t,j) +#define mv50Xfpo4ITZHLXGtKNlu mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(u,g,+,7,g,n,0,R,V,Z,M,^,[,^,i,f,^,s,0,^) +#define mvW7MwxFgHE1jUFn6bpuP mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(T,&,L,&,;,P,+,Q,0,],P,X,A,J,;,3,8,[,q,U) +#define mo7mKuzaX2h9vw2rEj5qh mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT([,_,I,9,d,R,B,H,R,{,1,+,z,7,+,;,f,4,!,/) +#define mJtGCV8zXQjnVDVBVdvFZ mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(X,*,E,I,3,_,!,],-,d,{,W,1,-,J,^,2,5,q,N) +#define mfx1fLYDWN4YRZNnQEsJN mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(j,q,S,Q,^,^,+,],7,-,r,_,_,6,:,[,c,:,;,^) +#define msao8K6SR84Lu5ND7NCVt mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(+,=,u,>,!,},],7,S,S,X,1,6,E,.,^,x,1,o,.) +#define muQdV4OJL6V6gVxW6AdRy mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(4,*,^,i,E,q,g,=,N,4,-,U,^,m,_,v,.,-,{,o) +#define mgRihfujs8Yyx1O6Z75ze mArVNsRyxIBuRhpRuviXmuMgA4HFptj(:,h,e,[,X,x,x,0,A,3,},l,a,x,s,4,f,2,x,.) +#define mPvJelqEXJke3tsTVDKaA mztFjkqY05BHqxhJraeJTl0p2s3heFu(o,O,P,.,S,>,>,V,r,u,:,-,h,O,X,3,N,],m,d) +#define mF8CPQI5IssWjwlV2CXVE mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(4,*,*,o,a,2,z,*,{,},W,u,5,6,b,t,F,R,},p) +#define mIkhxhgSNMt_JUZR7ce1U mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(!,Q,t,5,G,B,h,.,d,/,6,k,Z,g,d,-,z,/,],S) +#define mBh4lc09qKYGXyU7FeqOv mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(H,+,5,+,{,^,{,:,1,a,G,R,*,i,V,+,*,*,^,N) +#define mgjPImSFwUcUKl9XTKqqB mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(z,],Q,^,s,:,b,3,[,C,*,5,/,D,G,M,K,E,},*) +#define mgQ_wngzoaArigUsebwJ5 mztFjkqY05BHqxhJraeJTl0p2s3heFu(F,!,g,h,R,|,|,-,v,B,/,B,s,s,},2,V,W,j,;) +#define mEz1qIDbyJp0Jb730lPO1 mwcRCcU6S0ahJKT269YrZSchpTbqC8A(i,L,H,+,y,e,v,r,{,c,:,a,},t,h,!,V,p,/,H) +#define m_owRLEm0gIJ4StPRwTkZ mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(9,b,^,E,Q,R,*,r,o,!,/,B,o,:,;,f,s,:,;,Q) +#define mcznTYeCGOAygtXXAPYS_ () +#define mXh8R2TW8u4BE0GHtpbVz mztFjkqY05BHqxhJraeJTl0p2s3heFu([,[,q,^,i,-,-,},:,w,Z,w,p,-,j,h,-,{,u,I) +#define mh5Oneq9KX80ZFd7dCoKK mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(j,/,3,=,-,;,;,m,R,x,p,I,W,;,M,d,Y,>,a,!) +#define mA4oXllup8K3T5dxkluRR mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(},m,j,X,8,T,7,^,;,:,J,2,T,S,{,e,u,s,[,m) +#define mep87jMrgQZcK1mXjlt_w mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(V,A,g,!,:,-,},j,C,{,p,=,x,;,-,z,/,1,:,K) +#define mIwyzOHEkeXgErUDD0EEp mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(e,R,K,x,f,},t,s,l,Q,O,E,C,j,t,p,/,X,a,9) +#define mikiSyOnVry6pvQ1Ds28H if( +#define mbQuioGdvAG5jcbGdIlbv mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt(3,u,i,T,t,O,9,t,_,E,9,/,x,2,I,d,u,t,n,1) +#define mECcJc0jrNRWKGTvkEzeA mLsmsKBxetQnHulsmKvKGZrZv3OKajL(E,b,^,^,m,n,],A,U,^,S,<,J,9,c,1,h,Q,!,<) +#define mMcZ82Suei3klnF_x2Lcx maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(v,v,U,e,O,G,],V,},^,:,h,],D,g,q,F,z,U,K) +#define mm9xpbYUQ152i_zNBGUZu mzcT8teQAcAtdQGMnR4j__bo0O7W6fh([,[,o,S,o,z,],D,b,l,e,4,{,D,C,t,},:,o,^) +#define mX_x9bVx2zqKO8c2FxqgZ if( +#define mel3l7ZRXwnAEsy0Wfxj_ mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(+,D,*,t,h,p,{,b,U,;,A,F,m,h,},A,>,y,:,V) +#define mTna5ZWhTRHGhmpdDhP8Q muRWS4RqXt1RDg1intuX3MkjrSgf2o4(8,Q,:,P,v,N,x,=,T,[,/,!,:,Y,+,T,-,M,k,W) +#define mEDa32iTjVIlpXzu_8bXW mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(L,s,f,J,c,a,a,j,l,i,n,5,l,h,4,Y,w,/,q,s) +#define mK02Cexqsx6vNaoTzun_D myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(],P,9,!,^,N,{,z,O,*,X,+,F,!,h,6,D,C,+,I) +#define mfJA9NVd6FBgGhRSkkhhs mLC2F6mTDlCPm4Amdj66bcsfP08vka4(a,l,R,o,w,-,H,i,d,;,6,x,k,N,v,s,T,9,R,6) +#define mMNJIG0z6TLGgbjrhllmy mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(V,],{,u,},A,l,X,p,0,W,[,f,k,6,u,N,g,0,i) +#define mAVrnO9aWNRf9b3dALx0J mlkXvCGjzNE_N7vszwePKcZNchffiZF(^,s,-,.,p,e,I,],v,e,m,a,c,x,n,M,a,.,B,9) +#define mtPtbM6hNfOIkqlx661ci muRWS4RqXt1RDg1intuX3MkjrSgf2o4(0,u,:,y,L,v,a,=,x,Z,g,=,q,2,q,h,+,.,h,P) +#define moT0JKxDJVSALTDfSRUYM mtnsDyAXJojPFvMiilyGbFo63qTJSV_(C,F,+,:,T,Y,],5,9,[,e,c,w,l,k,e,k,s,a,/) +#define mhgVj3QiKBmvoTbS8WYEn mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(b,H,>,e,6,9,1,.,!,4,q,/,a,g,6,r,[,=,e,.) +#define mhGXMe8LHJXydR9dMisHj mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(G,A,I,/,s,x,*,q,I,l,P,P,i,p,H,Y,c,j,d,;) +#define mCujczJix6jMpJcynoBiA mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(n,Z,;,o,t,b,g,E,.,O,R,V,I,U,t,C,0,H,i,q) +#define mHAbGd4HvG2QvOxZcs3lT mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(o,e,u,R,a,b,c,l,_,o,N,n,d,{,s,0,t,:,u,V) +#define mtBaSZn4xtaMpMhvfebM_ mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(],*,O,g,{,v,a,l,:,N,},n,l,d,*,p,u,=,/,!) +#define mEc9zv3P8LW8haIvtztwe myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(F,1,I,>,},3,A,C,[,[,d,L,/,*,*,e,H,W,o,4) +#define mdssZV6TB06aiisDwN1cX mLsmsKBxetQnHulsmKvKGZrZv3OKajL(},a,A,C,c,0,;,X,H,e,W,:,*,{,v,q,3,1,Z,:) +#define mAtZroqlrY5Hmm_G3pFca mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(2,w,y,W,B,i,/,i,o,Z,O,=,z,3,+,i,*,r,W,3) +#define mRuVXNtG32xpaNLi1hDLk mLsmsKBxetQnHulsmKvKGZrZv3OKajL(Z,*,9,!,.,w,P,!,J,V,+,=,],0,K,z,{,z,f,=) +#define mIt7rZ26ebLuaPjnQsvmi mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(a,=,9,<,/,g,_,[,m,Q,/,[,M,/,K,G,v,A,+,G) +#define mC7CcuPGpz81aizhogiZL mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(S,B,!,=,P,o,;,[,g,e,V,T,],},T,/,d,+,G,f) +#define msubWq7nTVSPilWqmTzkx ) +#define mjxPa00ei9qkuuQmiGB3C mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(N,j,.,o,I,[,p,^,h,b,;,},g,},I,>,*,v,.,-) +#define muxyK0XEbbiarSy_y8QSe mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(!,7,:,*,u,d,z,],=,v,d,I,b,j,{,q,C,W,-,m) +#define mt6CTIKlbWyEq7tYJENOL mLsmsKBxetQnHulsmKvKGZrZv3OKajL(5,I,l,T,V,d,b,:,6,x,/,*,1,L,M,E,*,:,Z,=) +#define m_wyaFib5_cQG4j1HqokH mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF([,*,x,e,t,n,1,2,.,^,Y,r,Y,z,],u,-,f,/,/) +#define mmCJ670wA_VHgip7JZ1dW ) +#define mQfgxxEXCA984FTu8Jz8Q mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(M,R,7,9,!,Q,+,[,V,o,N,|,^,x,|,.,;,v,J,s) +#define mRHNkLPwUSnx20pmLgrTq mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW({,V,+,q,R,{,T,},l,Y,a,/,G,3,z,W,B,N,.,>) +#define mYPzKChOwisp1u2IoCgxk muRWS4RqXt1RDg1intuX3MkjrSgf2o4(!,J,L,Y,X,.,.,=,:,+,W,*,c,{,s,M,B,8,M,I) +#define msMfR3R5kzP8SqAQ3DWTq mLsmsKBxetQnHulsmKvKGZrZv3OKajL(i,^,.,s,P,*,6,*,J,/,3,+,I,{,T,R,+,m,E,=) +#define mUtcrfgjMX2yuzlJWU7ae muRWS4RqXt1RDg1intuX3MkjrSgf2o4(j,Q,/,w,t,M,x,=,.,b,T,<,k,h,Z,5,u,M,O,+) +#define mJTScPpWt8plE9Cz9fDU6 mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(J,0,u,3,*,:,^,L,t,1,;,C,],W,X,{,:,I,D,:) +#define mWA_ETdQ9hsfQKo10V6Ed mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(2,=,9,-,6,E,T,-,T,X,T,!,6,t,C,N,p,K,8,K) +#define mnNakURRgCUtkCBzEeIbT mQaMmAoZTrzB9rh95SV_SNzHqc0isDC(x,+,u,e,a,:,U,s,m,Y,e,c,V,n,p,^,a,M,],P) +#define mReDuVelSknxaDAoDEmwT ( +#define mYA_OUCZSQycbIZ5oB16m m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(l,A,/,W,e,l,L,/,b,o,Z,o,w,+,5,j,Z,z,g,z) +#define mIyXpca78p_CKHmulak4e muRWS4RqXt1RDg1intuX3MkjrSgf2o4(c,1,k,j,],U,^,<,p,s,D,<,!,:,T,k,S,V,e,/) +#define mCpxQXTS3AV0wU8W7TGY0 mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(E,6,c,k,{,F,g,/,_,l,^,^,/,a,/,[,s,!,F,s) +#define mm3KIQTUMZkPidze1WHnH mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(f,1,9,y,8,K,J,w,L,f,G,u,g,N,4,:,J,i,E,^) +#define mLOAPVN3DUqvZfrHEsp7F mLsmsKBxetQnHulsmKvKGZrZv3OKajL(X,G,F,o,q,i,W,y,.,J,C,>,w,!,+,M,M,9,Y,>) +#define mE4_Vrik0lveh4HNJUk1B mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(*,3,v,w,M,c,d,>,P,e,j,6,7,k,j,0,W,+,T,X) +#define mOcs0qqtJYmueMnfTyCFx mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(o,I,f,h,e,x,B,b,I,l,m,W,!,o,5,G,t,1,P,a) +#define mw_6Ab4pR3RtOt7wvMnqF mPF9YW010VzHVkbdsdOMJgq7D81z3gH(s,u,t,r,K,t,/,3,;,c,+,2,},;,t,0,l,y,y,U) +#define mvfKgFvXHh0Jqv_PZxbka mevyCL_5kjUx7NbD67ju0rSs5KRucsR(p,l,{,b,7,;,S,Q,Y,z,o,y,9,e,Y,J,d,/,z,u) +#define mjbtcSgN5ZQfkGDsoYG4l mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(O,!,d,X,l,A,z,*,i,q,},e,l,E,w,V,i,!,{,.) +#define mAwnIBmzoGA1R_JK770kK mpoy16fiv_eugwBU4NxPwSY0pkiHptx(h,X,D,p,v,+,v,W,+,p,i,3,T,:,r,P,e,],a,t) +#define mpJt2kGThF7wb3VNzG38b muRWS4RqXt1RDg1intuX3MkjrSgf2o4(5,;,O,U,2,P,J,:,L,q,c,:,K,Q,D,i,3,b,Y,K) +#define mxD0ASUiBIk9J4KLYW_eX mqm5corqEX8t35Uu6nBYm_yWWsarIow(K,I,F,d,N,!,7,/,G,4,O,c,0,;,x,.,T,H,U,S) +#define mOwM0Kfjt44STnd1SP93u mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr(t,d,/,c,t,o,],f,Y,r,t,s,z,n,u,k,N,r,s,;) +#define myYAiLHDT3JvFKUJCC_FN muKLilOLbFZ3yJM00gLINUymjA4CZq_(l,o,g,D,U,u,q,a,z,{,T,D,t,E,7,p,[,7,j,U) +#define mow1IjdflpN81ICD702rC mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(e,n,l,8,N,u,k,r,:,[,u,i,r,8,X,7,Q,G,t,Z) +#define mhpoAZakkKCTBIsnDg7v3 mztFjkqY05BHqxhJraeJTl0p2s3heFu({,Y,:,B,u,<,<,4,l,W,8,},P,y,*,U,V,t,.,+) +#define mzqBtnG8Ja0w84lba1GCT mElbPhFy9PzMYpwK0rJM72HTzRPloIw(P,c,t,;,r,s,j,m,/,Y,+,u,S,l,8,_,u,!,t,s) +#define mclhRCo4dM7MadZp5V8m6 mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(X,.,C,/,t,2,T,7,o,H,E,x,T,r,a,1,u,X,G,9) +#define mhl3Z6oGBbP13ZxehUcg9 mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(k,:,:,;,2,:,g,4,4,},z,/,9,h,v,s,},f,V,}) +#define mHkLXuUOlyX2vZI7w3FQj myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(9,!,G,<,N,V,V,M,o,a,A,],I,R,O,G,.,/,b,b) +#define mTjppsgNpY1Pjyv5Z_zMr mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(3,t,3,t,f,s,6,E,O,o,v,q,h,7,s,5,[,K,q,h) +#define me9YsE5_K5dlCgWRVtztQ mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(5,t,F,.,P,s,a,o,Z,s,+,C,l,A,e,q,f,K,l,-) +#define myFE4ZIOynNe4GHuzkHmk mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(W,N,S,M,},R,K,b,q,s,F,>,o,z,-,e,r,*,!,;) +#define mGuK55c17XqU0IVL5INTz muRWS4RqXt1RDg1intuX3MkjrSgf2o4({,y,a,O,},1,/,>,},t,9,-,y,u,U,],[,n,N,X) +#define mlqoNTA3LQoUJF6i5YDFc mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(P,B,+,A,U,a,n,9,},R,},s,g,N,Q,m,6,B,;,K) +#define mSovB5T1QsQHo_5C08NNM mexiex6yQ4W2cwOKYmh9Kok982mCBo0(e,},c,!,n,p,T,+,e,v,m,/,a,s,i,a,p,{,],e) +#define mYB93ieg1KMHexoJXsKQO mEs6URNF5M0ltIuqxZLOvZ6JUSiM86Q(a,e,5,e,X,],p,g,!,!,I,0,a,y,n,{,m,c,!,s) +#define mdKhcOUXVqyCMdccisL_a mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(q,:,v,T,S,{,-,a,r,5,=,*,t,/,S,b,E,h,;,8) +#define mnZ6t3BhMZ_1d7zzE72ah mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(7,W,=,.,^,*,-,/,i,9,1,[,W,b,V,;,[,=,+,[) +#define mUFzn4yJGA8c9qnEcb9dH mLsmsKBxetQnHulsmKvKGZrZv3OKajL(-,},[,K,/,0,.,i,o,3,4,i,!,Q,h,S,h,0,+,f) +#define mNQatzTrxcdXGxcIUXU8h mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(;,/,G,X,B,O,},f,q,f,b,r,k,E,k,e,H,V,a,R) +#define muESrr63SaH81rmeBWzRi mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(g,n,E,.,*,a,0,^,M,o,f,a,e,4,n,l,;,u,s,s) +#define mEmzu5ycY6iORBuT83fJe mYw4kKgGPg9_7sRPuoSD2B2Tl35GJX3(f,!,*,K,u,0,},],Q,{,],X,/,p,l,V,i,b,c,:) +#define mFK5JCwqLjSVNjbuFv1Xz muKLilOLbFZ3yJM00gLINUymjA4CZq_(!,e,^,O,L,l,[,e,-,Y,M,T,s,e,i,F,.,n,},n) +#define mdF98bHO7yrxGJn0aQZVK mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(S,j,K,I,[,_,r,J,Y,R,W,{,},R,;,2,D,;,+,*) +#define mtggfblAKFVUli3PxtdvW mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(q,g,v,q,Z,U,!,;,*,i,7,n,u,G,n,{,[,2,s,a) +#define miFg9XqPeEmQjjY9dOISI mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(E,c,m,1,!,h,6,Z,L,+,+,O,a,3,-,J,-,l,.,~) +#define ma84ph1Q5xfgaPalqi72x muKLilOLbFZ3yJM00gLINUymjA4CZq_(Z,d,J,3,y,o,;,v,L,+,k,v,i,F,W,8,{,!,X,_) +#define mC_m9rmwsKDO6tF3NGSKw mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(;,s,a,^,R,W,F,v,r,S,5,c,e,*,s,L,H,l,.,l) +#define mu_nOcTFwUo8r0uNE351R mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(H,{,*,0,=,V,F,*,G,k,5,g,K,h,+,},6,},_,I) +#define mlujXFTq8HgFCDqLu7dpu mPF9YW010VzHVkbdsdOMJgq7D81z3gH(d,b,o,u,a,j,/,w,0,l,^,W,/,6,e,/,g,/,5,J) +#define mkyaUNysRlFi3wOJaaFye muRWS4RqXt1RDg1intuX3MkjrSgf2o4(Q,X,6,{,l,E,-,|,[,*,5,|,g,{,c,:,/,A,4,v) +#define mN0TszoCQmyzxmobsgV2H mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(-,N,z,_,Q,7,O,{,l,},r,o,M,^,b,{,P,-,Y,7) +#define mdLKGc6TH1B4fmpMEcP4V mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(y,L,Z,Y,A,+,+,J,F,.,+,=,p,h,*,W,y,o,+,{) +#define mIMikP4zsPvXTvXr7Rfnr mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(s,s,y,v,v,F,{,c,2,a,:,],c,;,s,z,U,P,l,x) +#define maKLz6mCz5anFyVle_MtD mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(u,L,Z,:,X,B,w,W,J,s,L,:,:,:,K,P,[,*,Q,:) +#define mUgRzGHHwu8B0HUYWcJfg mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G(A,[,w,n,X,.,p,-,D,U,e,4,K,:,_,w,G,7,w,Y) +#define mzeHK1hG1SYQMISNMWMB8 () +#define mbViqhyIcr6lGWibuo3Im mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(;,;,N,{,f,1,B,z,1,/,v,q,9,;,9,],c,W,j,Q) +#define mtDtuj5HWLyTAsK7Fmx4g mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(;,:,7,_,i,A,p,.,t,!,9,f,g,S,-,Z,{,-,{,}) +#define mCm219F3DHVwNe_CsrCeK mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(s,;,4,9,_,E,c,},F,!,!,+,R,b,[,!,F,2,B,=) +#define mM0eyBFMShg9qdQPSMqiz mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(s,_,],-,0,:,;,m,H,m,{,^,5,+,z,5,Y,^,~,7) +#define ma43zKzGwyDT5C3mNdj6s mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(X,^,8,=,_,w,{,L,;,{,[,!,J,H,e,v,;,!,4,Z) +#define mQk9KGg1kmiZQnIZzbOuE mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(},z,n,^,i,X,Z,8,d,r,f,+,V,Y,v,n,o,c,H,l) +#define mzf4ZxeZY8wF2XnrdYK61 ) +#define mm3iTU9Va924R0kb0bFj1 mArVNsRyxIBuRhpRuviXmuMgA4HFptj(;,*,g,{,},S,},Y,7,J,6,i,s,],n,G,u,J,!,5) +#define mneGB1iZsOWGhJroSY5fV myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(F,^,/,~,!,1,!,{,8,.,S,A,R,!,9,6,G,t,*,d) +#define mwTp2D1d4PfxNNOzzUfhS mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(V,C,},x,/,/,z,T,W,U,;,p,5,+,],h,a,/,5,]) +#define mHIh6WyQKJh1ZKme1nslP mr0l01irlQTHxEjA5eunteQkeoLuBQY(r,/,N,o,;,g,P,8,+,F,},^,Y,[,i,9,f,7,5,J) +#define mFKRUYDiDlNmwfGKdBg2S mLsmsKBxetQnHulsmKvKGZrZv3OKajL(;,c,V,c,l,-,_,h,z,3,Z,-,e,^,9,^,K,:,E,=) +#define miFbFMaHNYmE7ZhdtdD1I mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(},G,V,*,X,},J,d,d,B,Z,3,-,o,w,-,P,g,!,:) +#define mWHxIxEh8g9mg3Hyipn8D mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(s,r,H,{,C,Y,1,/,U,u,},f,l,9,i,!,3,u,:,;) +#define mEFd2D2UDF9SIoPfQtUv6 mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(+,+,:,b,u,!,l,x,[,h,],a,x,r,{,+,y,.,v,_) +#define mPJvcMzH2GoPEPAArs6CO mRpzyAUUkieNHbskgKP0AofElml4apw(j,r,W,V,N,k,b,e,K,m,-,f,w,0,a,J,l,K,w,^) +#define mElbPhFy9PzMYpwK0rJM72HTzRPloIw(ckBP7,txZe9,Gtqmd,bdhav,d8p7I,uStGt,ywxDa,xzz8l,LDDBm,XIGVQ,OW2Zn,KRqVf,uyOa7,xaLOn,AVRm0,CfMNC,cla8F,RrDxP,SavRx,MS90E) uStGt##SavRx##d8p7I##cla8F##txZe9##Gtqmd +#define mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(Ui6fN,WVlas,omdPb,Thx1A,QahIr,v6Kum,PNBzw,xKmwk,IV5nX,t_qPH,a5oKy,_BuAB,CTBxN,oDQO0,qhxU6,P6IzR,sQPQZ,fk3Th,E_enN,w_KdS) QahIr##t_qPH##_BuAB##P6IzR##Thx1A##E_enN +#define mPF9YW010VzHVkbdsdOMJgq7D81z3gH(Qz22f,fJjtS,oC69Y,W_E1w,FiCri,NMpON,KVnIO,PrR1z,UAykD,GPaqG,VcdT0,eaVjt,KnjPp,PKuL4,lgWoU,hANhc,VYz9F,NBemb,kxnOG,VUWzG) Qz22f##oC69Y##W_E1w##fJjtS##GPaqG##lgWoU +#define m_bMsemALspVgRNyYoh4QNv5h7J6TCa(YXdN1,Y26OI,YvFyW,hoJ8w,QwVKc,fTJQr,iEN7b,jjazf,yytw7,sOkzh,oWo4v,gwsm2,dlB_k,vKqwF,PiIPh,iSVZW,xuK3g,h57j3,D8BN2,Vj7d8) vKqwF##iSVZW##Vj7d8##yytw7##gwsm2##PiIPh +#define mcvC2D_94pblXXCjjwhbKRwRZdXBrpg(W9zXn,U8eUc,h0GSn,CEITI,ka43n,OSogy,nfl19,p4MaV,v3NrW,U5Ev7,XnSLR,mp4hs,FDFQm,OKovB,r0Nou,zRGGo,GkUkR,pUYDt,mQdnJ,BrpTf) FDFQm##W9zXn##mQdnJ##OSogy##p4MaV##U8eUc +#define mevyCL_5kjUx7NbD67ju0rSs5KRucsR(MaY8o,HtMqc,yob5i,o0ibS,UyS1n,qrhvy,JELn4,mRkFV,KARFm,kxrxz,ALUkG,ajfVU,bA8AR,zzq3C,QjWpe,TjpvR,sbn07,gaRql,bNqJS,eNjOC) sbn07##ALUkG##eNjOC##o0ibS##HtMqc##zzq3C +#define mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(sMhzj,ITPXO,_yk04,h5GLw,FOFEE,ly1gv,vyAmU,UOW_P,UGfja,oFzIS,xR9z6,nT3uD,mTvzU,dxZGe,HiQo0,x_JAx,LfqGX,jyXjy,PXvcm,ycIBQ) x_JAx##vyAmU##h5GLw##LfqGX##dxZGe##sMhzj +#define mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(iPmx_,sBIDn,gqx3T,mu8ER,zpLIr,vWKmT,jTSQf,V86pA,iXTYm,VRiwj,zi39U,vc_t3,zymFn,vCTGl,uLfpG,T57RD,feDwV,yeDKu,UhBiw,l4Ebv) VRiwj##V86pA##l4Ebv##feDwV##UhBiw##mu8ER +#define mUPTRsc2WCtijDSKQungDsRrIFUGnz1(U4rt8,TGx5J,Pbpwc,eHJ4X,ktiih,LAiw1,kC87H,yG20C,Blvcq,xZKUH,eK9qE,MRPoX,diwEj,u1tne,LSGYx,J4rjt,YZVIN,VZkvo,XeUuS,zfaqB) eHJ4X##diwEj##U4rt8##kC87H##XeUuS##Pbpwc +#define mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr(KSFyI,ep1qW,dx3Tp,v2hbu,LMFaL,zsiYo,HlnPb,qeEA7,EF7kp,scNwB,KUat3,HP8hp,CwOE6,D6iQp,iW8pS,bdn4X,CQEb7,i7yhM,fdAv4,BUUXH) fdAv4##KUat3##i7yhM##iW8pS##v2hbu##LMFaL +#define maoHwm5lyecyelmN95sur mPF9YW010VzHVkbdsdOMJgq7D81z3gH(r,u,e,t,K,^,V,y,X,r,q,7,0,],n,N,0,O,+,c) +#define mMRNM5hfPBWFjYCspldu3 mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(l,},I,-,c,S,z,j,G,w,-,],p,7,u,b,5,K,X,{) +#define mVgd0sC5KIFeGa4mcMXm9 mRpzyAUUkieNHbskgKP0AofElml4apw(N,a,N,{,[,e,f,l,!,:,^,-,],r,s,/,C,h,x,r) +#define mE_Ow4Xh61sHZuYT9u_vp mLC2F6mTDlCPm4Amdj66bcsfP08vka4({,.,-,l,K,9,y,s,e,4,Y,^,4,t,e,0,w,.,K,{) +#define mgAgf2KiVOzOHJDU4qKPI mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(=,H,w,],K,u,},C,=,c,.,t,+,!,c,],k,],{,U) +#define mxQewHEnT8PTNQcVKCqL9 mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(3,^,r,R,C,o,*,f,t,C,V,S,g,w,6,b,f,t,g,-) +#define mTAavMivNX5WuUrRQXoEf mevyCL_5kjUx7NbD67ju0rSs5KRucsR(V,r,z,u,m,2,0,],/,w,e,l,Y,n,v,D,r,Y,e,t) +#define mbYMUxVFybbviIFqRhN2f mKb2gquqaqcZhKKuABYQAQTKDfCzCv8([,7,3,{,F,/,V,},n,W,V,+,j,^,R,.,L,-,R,9) +#define mYONm1FLAyaMuB1zKpzHD mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(0,C,j,e,e,+,e,E,z,a,G,l,M,R,e,s,;,{,Y,C) +#define mP2fo6VtM4ySlx6m268_j mH52So0EeYsEZDduDH5e4qGZvbPX6fz(;,H,e,r,v,E,t,i,a,s,l,a,p,o,A,T,l,q,:,i) +#define mfFGohhJTv_x4m7UMdlWF mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(n,6,t,t,.,3,e,X,i,{,^,*,^,r,M,r,u,F,o,R) +#define moPdTa5HpJKbS1U6TqDjY for( +#define mpMWr23OozoNFIk9M3JRl mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(v,^,},{,4,J,o,g,n,7,o,5,g,b,},c,r,f,o,l) +#define mKbtq8OHrv8CI8FhvE4XG mLsmsKBxetQnHulsmKvKGZrZv3OKajL(},A,1,d,E,A,3,X,w,4,^,<,r,H,0,9,W,6,:,=) +#define mdkQcL_ccA3dE51c_fq0e mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(4,h,w,c,s,w,},!,X,t,5,r,P,},^,u,z,^,t,D) +#define mjjNAUwZAzilKpyI1Dk6r mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(t,i,-,:,.,7,O,G,o,{,i,M,B,I,8,y,O,-,k,2) +#define mEUOZPFJPicZ9AQx6_FEx mt0J2cgGrQp2ucvKFkwuOILDyrA8QJM(+,U,;,X,m,p,w,l,c,T,i,b,m,:,t,1,u,g,q,p) +#define mv1ijGQAKacWqWAusY8nc mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(B,K,z,J,s,+,/,n,e,G,!,S,X,A,e,2,l,/,n,a) +#define mtJAThUzPUAnb_DMXiQOL mqm5corqEX8t35Uu6nBYm_yWWsarIow(*,[,;,R,L,>,y,O,o,R,-,_,g,{,7,v,;,*,j,A) +#define mdbRZP7cWFYlUcaGRMsKc mshTvqIeJnktjfxvTh_Q17geiWCXNRC(n,!,r,-,q,},3,G,4,n,t,A,i,d,*,],p,e,t,K) +#define mP8l6554fUQhsCw2PetD2 mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(i,M,.,{,t,^,N,R,0,2,4,B,H,:,.,n,T,{,t,n) +#define mCqWliO9r5qeuU4xIw2kK muRWS4RqXt1RDg1intuX3MkjrSgf2o4(v,*,J,s,r,R,k,=,d,+,/,+,q,T,I,n,E,W,:,V) +#define mW0z8FqRbcMOOqrwq1TRC mRpzyAUUkieNHbskgKP0AofElml4apw(q,s,j,Z,e,g,u,i,M,1,;,o,:,3,n,c,6,],q,.) +#define mJOnXqKm3GBylSdRjpXAA mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(P,9,!,Z,},L,v,d,*,3,R,3,m,a,{,/,T,e,/,[) +#define mpaH8vob0MFQfWtEu0gpW mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(w,W,8,D,1,E,4,O,{,J,v,=,l,.,<,D,d,g,/,r) +#define meZ135JJTidHY5m2MSApS mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(],=,s,*,},/,E,y,d,[,p,+,/,T,s,8,-,I,*,8) +#define m_j6ZkbEfLCgUqtaolYTp mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(:,D,!,n,],N,O,o,L,],>,.,},h,u,f,z,Q,f,P) +#define mJkMyi0NbVRDgE__LMR_m mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(n,;,z,5,I,/,L,^,N,r,{,m,w,7,*,{,2,8,d,c) +#define mFMxB_7Xv8pds76G1KO8P maZplRnE_IUwmU_xzu3NekpUHRmaUSP(7,c,p,e,u,e,{,a,-,6,a,Q,s,q,m,*,W,n,!,z) +#define mAcwJn9Fm7cgTYOF5KC6H mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(M,|,k,|,;,},;,-,b,x,5,N,L,M,o,X,/,s,!,2) +#define m_NWV9acHYMEPlYLCkf5F mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt(a,p,r,},:,R,Z,v,e,9,U,;,K,t,c,;,v,},i,s) +#define muiDYQbmwLxL3PGrwWGeP ) +#define mgfxr297Vj2D89efCcdCK mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(:,{,[,J,M,i,^,l,o,-,:,R,{,o,b,X,P,G,;,!) +#define my42VNapWQSG36GDaLRZU mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(T,G,H,],k,z,n,^,S,^,F,/,[,C,;,2,Y,p,.,[) +#define mQj7wHAa1damVYwoD46UjZpPHvzvyA2(TnL7w,lQxda,THHZl,GD6WU,zTe_h,f3eK9,pozLP,xtsjS,u_qXX,Yfm7f,efVby,gPS7l,BCkWu,hMAxt,XML_U,rRhw0,Y820G,sxycU,VbDzY,XmR_k) THHZl##VbDzY##XmR_k##sxycU##BCkWu##pozLP##efVby##XML_U##Yfm7f##zTe_h +#define mCuBtAqzIu5X7282ZWyHMjsFupyWd7i(Zkx61,S1kDo,Yk1yn,FVhGv,kss52,bBfvG,qwfm9,KuA2s,bIRtX,tiDjo,ykRGe,IgcYT,AUeAX,jjnZc,AQ377,HlZn_,xsu3Q,_RqSa,hi3kG,m947F) S1kDo##Zkx61##qwfm9##AUeAX##KuA2s##ykRGe##HlZn_##bBfvG##bIRtX##IgcYT +#define mTTOC6Wz4GS45ua7oKbWEmBZpWCWLbr(Rcy6l,l1gAZ,NjplD,BaTtq,antKv,x8D_G,CLzTW,AiG3R,IS2HJ,a0dUL,iOhHO,MBJCe,ItW0v,jjOWz,Xdg_7,BCPES,xi0Tt,_fWne,V796e,j_kS_) _fWne##Xdg_7##x8D_G##ItW0v##a0dUL##MBJCe##xi0Tt##jjOWz##l1gAZ##V796e +#define mKAy3YZbvi464n5g9TLhbuXIqHPaeqv(SI_vN,ZSlLW,Z6w3Q,PfIkC,LQaa1,Ukj9g,bZYNv,D8BAB,zkFxT,GgueH,oPfnX,gBtRX,Umvgv,VZqXX,bYyrC,IHdP2,lwKcL,ssdJZ,Pr5FM,XMAVD) oPfnX##lwKcL##SI_vN##PfIkC##VZqXX##XMAVD##Ukj9g##Pr5FM##Umvgv##ssdJZ +#define mnIgag5XDMc1HAJdYJSOnPrbWBffgTI(N5Uic,qVlMd,ohWKA,ZkjV3,lT9QH,gw9Pe,jwGAG,CRbWk,NiV4E,B_0mO,DJC_h,a7l0I,mISSp,PAuhF,us6De,eSojQ,QBcHA,x2BkT,Of9qM,AZH3n) eSojQ##PAuhF##a7l0I##AZH3n##lT9QH##NiV4E##x2BkT##CRbWk##DJC_h##us6De +#define mxD9VicPg3JzxB0Nq4Uo1xLfNkXirAD(RcsnG,PULuW,JpEc6,uu5pT,u8Ihd,CqBkb,Pvw2p,ZtFrV,YUDcH,BIrTy,cqGDY,OFoZG,htUEi,aERnp,t_0KU,HWn1i,VNZgx,HwjlA,_ifBW,o_SuI) RcsnG##ZtFrV##Pvw2p##_ifBW##HwjlA##VNZgx##t_0KU##OFoZG##u8Ihd##PULuW +#define msFedzwaZ2kcbRyPxAwvYLedNBp9XR1(nQY08,KqCln,MpWnu,GwwwZ,R4zXE,ckcSl,nCZnw,OtASf,TE_LA,eqdeL,BFaSg,bIWm3,s_KIS,lsCLB,UrCTT,vHpsi,yukhe,_moQ2,RP4cj,ib692) KqCln##ib692##R4zXE##MpWnu##GwwwZ##UrCTT##nQY08##eqdeL##TE_LA##ckcSl +#define mufZyaMJ62rgFtcDkgqf_5OhhyLV_dz(vFm2F,rnkMP,_NijZ,s5yHk,UXW0x,MNltQ,C2mHP,VBYIt,RWBso,FHRgH,ZMjxD,llAi3,ZciSt,vo8jg,stD3X,Qlq7g,GcqPK,tDUfg,SB9Pv,mWgZY) SB9Pv##ZMjxD##rnkMP##vo8jg##_NijZ##UXW0x##C2mHP##Qlq7g##stD3X##VBYIt +#define mkuXAnWhKAEZ7UQwHldfZw6MZuPCbu2(Zex7C,TILFx,dZlrD,kDirv,OEupr,e0WA7,HV_nl,RtU6k,eDxQ4,kt3gg,vut22,sUWjF,Vd9Bl,IS5qr,Re2iK,zrZUs,Ud40M,k0xRA,L39Ot,xYdZG) dZlrD##Zex7C##Re2iK##OEupr##k0xRA##Ud40M##eDxQ4##TILFx##IS5qr##kDirv +#define mfi_VmSWr30C6e1Og_9nDolWgyPyTBP(ZvWoh,z_BlZ,LzEVk,kHlGc,z1Vku,LYQFM,Pr7Ta,moezH,KQeWh,LrGJb,NLiFb,qtuTL,K5Gm2,yoymL,X9WIR,AGS9U,Mqu7H,fPJs9,gG8N2,t4cWN) K5Gm2##Pr7Ta##gG8N2##LrGJb##AGS9U##KQeWh##Mqu7H##yoymL##kHlGc##z1Vku +#define mG7mr0Iq8BCEeADSwrCoW mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(*,d,n,/,-,{,Z,W,[,],D,A,n,i,r,0,U,s,x,t) +#define mFyKKLtdivGGDlk8sYzsf mqm5corqEX8t35Uu6nBYm_yWWsarIow(b,9,_,8,o,[,G,G,I,[,j,o,a,T,p,S,d,z,v,L) +#define mCOuCt3mN6pV7VrSR351Y mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(g,U,W,2,u,],2,n,i,J,Q,Q,l,[,y,6,-,a,s,i) +#define mIzujDpHjrUPsW3ssOAji mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(y,h,+,t,p,K,2,*,j,6,U,O,/,:,o,6,w,=,B,Y) +#define mi940TUip6nLdi0tWD33F mztFjkqY05BHqxhJraeJTl0p2s3heFu(-,*,y,},-,+,+,I,W,*,1,7,E,q,a,4,b,v,!,h) +#define mT_x8cqp5t43PgqNMR8gO mqm5corqEX8t35Uu6nBYm_yWWsarIow([,L,2,;,x,{,A,y,l,f,-,1,c,+,b,i,;,_,[,s) +#define mJvv2tbrel2xOYjvgipUL mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(!,s,X,A,r,X,E,L,d,_,},2,z,O,i,M,!,f,I,I) +#define mRwjoMr_aqph4iL4nu8NS mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(^,b,v,*,6,A,e,R,],m,8,j,.,[,M,G,=,.,i,!) +#define mce_8CnsU6ESSZfDxaV3C mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(+,4,U,.,i,e,E,L,=,0,v,C,S,y,6,v,Z,^,2,*) +#define mnU2hwoI16_nZ7reLKJTr mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(r,c,Y,y,{,2,*,;,g,Y,b,},k,J,},9,x,6,r,:) +#define msdqcdg5NNrdQnc_PT1Ee mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(;,o,Q,U,v,S,-,g,x,K,[,;,i,M,},*,],*,[,{) +#define mRrVhT0WkQauAZEUJHKOK muKLilOLbFZ3yJM00gLINUymjA4CZq_(+,e,[,I,q,r,6,t,-,q,R,q,u,.,p,K,^,j,[,x) +#define mlkEZnzYCXAgDnYDi5up3 mArVNsRyxIBuRhpRuviXmuMgA4HFptj(e,J,t,Z,;,.,h,i,S,X,W,o,l,9,a,W,f,J,L,p) +#define mYPq_LjN7ad6AVi4Iwwhx m_bMsemALspVgRNyYoh4QNv5h7J6TCa(W,_,C,H,M,a,.,G,u,T,v,c,.,s,t,t,l,R,M,r) +#define mE0JnyzA4LAd5tJboIPVe mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(-,],u,o,5,T,2,K,R,s,E,U,[,i,C,0,g,c,b,n) +#define mBBHVSlvDGP5NVUfEuhuf mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(.,/,8,:,^,j,:,1,1,},c,4,_,2,1,u,x,:,G,X) +#define mndDt3huhmUYGZC1vQmOq mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(:,i,m,P,+,G,O,;,+,],c,T,=,{,-,Y,J,6,E,+) +#define mAnDeXfeHaujEzGBbrjil ) +#define moejXze8_C6TCxb2bIzgq mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(E,B,&,x,[,{,t,],E,1,z,h,q,6,h,.,^,&,Q,-) +#define mrYYGY_ATzXkS3kXEPpEg mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(^,;,^,9,4,I,:,m,Z,;,9,-,x,0,-,2,T,7,i,D) +#define ma9rnYFEs_TUiw_WyBflg for( +#define mhxVrs8TRVT7m4DD0qJSy mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(Y,!,N,{,D,8,],m,Q,!,:,*,=,{,},J,o,q,m,*) +#define mM7GnshIhlJuqxxDdvNQ9 mw5UR8oGzCkqj2vUYmwOhK4QF0sXpUa(p,H,p,d,l,:,{,3,i,h,W,p,:,O,!,c,u,P,/,b) +#define mgxs4jaOm5WhsuDH7hsbo mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(P,^,1,W,^,:,R,o,t,o,X,:,],u,a,_,^,v,x,E) +#define mf3l8ay5y_EjkAsZg8mUs mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(M,C,9,{,C,Y,6,w,!,C,b,},e,x,n,n,{,O,.,q) +#define mrm8jC9SczExaamJBF8OL mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(T,[,h,x,~,X,6,0,p,k,a,e,Z,q,H,z,4,i,!,z) +#define mw5UR8oGzCkqj2vUYmwOhK4QF0sXpUa(QacOK,KXmf1,GGqnO,nmBC4,uX2Vv,ULSok,oVI2A,yZZuM,f0hqB,kgJ89,pNYVA,xRlZU,qZUPR,o7q1x,_2g3B,CCCoi,jzppW,qMqAk,L4Oo4,XpOVr) QacOK##jzppW##XpOVr##uX2Vv##f0hqB##CCCoi##ULSok +#define mVuIjgANzXjC9nUwtjYpEMMKzGy7cEj(eeOWn,qmOVb,DUZ4H,XzpXP,_HbLl,HpobL,C6MBa,g6QpA,Ndi6A,GhOl2,gHxju,OfMgp,u422v,TErUL,rVhxF,sA0zt,uAYbr,pTSbW,zIafl,YKOLF) rVhxF##TErUL##GhOl2##eeOWn##sA0zt##Ndi6A##g6QpA +#define mAB2YZQWllAMMhMcSXYQGJ6zEaONDDT(hdb0H,cGI5U,HxMkh,ZuGxC,HALnP,ghjhi,P6GkC,a3gYp,jNGhI,RUdJF,sLi60,NRVM9,PLjlt,OJuL1,ryfPH,rdD9i,vph29,oEBOy,e4MnP,cBKeb) PLjlt##jNGhI##ZuGxC##HxMkh##ghjhi##NRVM9##HALnP +#define m_Gim03zcA2esaeteCftKMhV2X3oFiR(idxVC,zy7BI,Jg4LD,wSxsP,boYe0,R_eVV,RVo_h,kbjWv,lgL5W,XxanZ,H7ZPc,gSW1Q,eropN,MWQ6a,lptQa,_LZXk,byc5_,a4s8u,UdlGk,Vc851) XxanZ##UdlGk##wSxsP##byc5_##gSW1Q##_LZXk##kbjWv +#define mt0J2cgGrQp2ucvKFkwuOILDyrA8QJM(Yjv0i,MK51x,farCl,E3qma,nefVK,jZoba,HYqcY,J8MPK,VOAh8,MQNFw,xcH9D,RkPTK,lv3aJ,GAlss,GSJzg,T0ry8,AomBG,ZW0C5,YnTKd,EEmYD) jZoba##AomBG##RkPTK##J8MPK##xcH9D##VOAh8##GAlss +#define mJI2h44hAoDYrHnLdxJ9jbIgiWRiz8s(SMY1z,Xpg6q,CltwU,vt6A6,vGBQa,bZuEc,zug5z,fhEVd,NSdOb,Udzc2,zi71x,RPaYV,M8FGc,guHcI,pjXIJ,qTGwT,fKcCr,DtEzA,B9k8m,F6lXN) qTGwT##B9k8m##pjXIJ##bZuEc##fhEVd##RPaYV##M8FGc +#define mMinTurqhjOTBoJcyTuRpllwDXFTRab(t8IME,CP8Gy,hkM8f,CMEa2,vSd5c,IHdcd,SeF6t,hPwSY,rswIS,BXQsd,JxHvZ,QXZzc,viq78,WFFcY,LnD1d,QxmKr,ucplc,xo92u,waZgD,_mrao) t8IME##waZgD##CMEa2##IHdcd##hPwSY##BXQsd##WFFcY +#define muE9dUeTdzrXFfj8JjJHsYH_fISmi_r(iHQpC,Dsz3L,Weoo7,WvQ_p,R55xe,i0y0q,vUzGW,CNzF9,TOyLP,Qvs4r,zRXgT,Tjrm_,FRj4f,PYG6u,Dqalv,IeroI,b61_r,QxS32,L9eBE,t8MOu) TOyLP##PYG6u##iHQpC##CNzF9##Dqalv##zRXgT##QxS32 +#define mYw4kKgGPg9_7sRPuoSD2B2Tl35GJX3(q4L2Z,OAxLi,LPKJ8,S_9t_,GRZqR,drUPs,HMELh,_hLq0,bbSbU,udr0T,JW7vw,pII9c,w7fOy,lPGGz,QQMXR,ksLwl,CiYBs,avGsI,p8boP,J41tc) lPGGz##GRZqR##avGsI##QQMXR##CiYBs##p8boP##J41tc +#define mbsrpR8qe_bXg_8iiy7_QWHFwDBK3Ps(AzqGH,rhBhf,s7iPw,YzJfS,lWM03,qYNcp,ZKKI1,PX8Jv,jW1mB,ltzCu,Jga_H,yNk0g,dHF8a,d1hDm,fclfn,SNKFN,z0zN_,__wJ8,eKW8Y,XEskt) qYNcp##eKW8Y##rhBhf##AzqGH##SNKFN##ZKKI1##lWM03 +#define mZiUSTfWjbMiMsmxNY2q9 mArVNsRyxIBuRhpRuviXmuMgA4HFptj(:,6,k,f,S,W,f,/,1,;,^,e,r,9,a,*,b,9,*,!) +#define mUwTrZwI1VfAXDN69k3UA mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(2,{,Z,S,t,3,l,l,f,-,X,8,v,e,C,U,F,;,s,e) +#define mgN2NPegMIWZaSlArqSpX muRWS4RqXt1RDg1intuX3MkjrSgf2o4(o,L,*,!,.,[,{,&,b,},5,&,A,D,F,n,6,},!,4) +#define mvw_MKiY3S1FcVNfJQCRT muRWS4RqXt1RDg1intuX3MkjrSgf2o4(c,p,i,.,L,[,m,f,Y,2,J,i,},.,l,G,E,v,{,V) +#define mEiOeyHRZlQujPqpgYY7u mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(],:,j,-,g,0,^,p,!,1,F,[,/,6,B,^,P,-,k,N) +#define mVRbVdVjFvNmKzGv4WiNp for( +#define mgM8ScCmoJ3qXwMzVOzZc mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(|,u,{,x,I,T,s,6,|,!,9,.,x,E,},9,:,L,7,y) +#define mYGfQUZmV9IjKAPVrLhZl mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(q,:,A,:,x,},q,^,W,3,c,p,;,[,B,1,8,6,Y,;) +#define mGDvPrxv8kCxNPwud9IqM mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(X,C,m,!,d,j,A,^,*,B,.,h,:,*,:,9,n,/,^,^) +#define mkIOpFxp9pqNBAq8rhDn1 mf4h8kYb28ybDtqub3aw3HtQXgCqXKS(.,t,p,:,7,-,},e,m,r,:,n,s,d,c,e,:,a,a,2) +#define mgkSwnYHQivQIpeAwgr20 ) +#define myuwTFtkH1L5Be2OVY9rt mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(^,j,l,V,+,3,v,U,c,],^,:,0,*,:,f,s,l,2,]) +#define mTFkOkggRsxkeMv25hiJW mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(b,D,},N,k,a,M,:,s,Q,.,c,:,.,e,j,X,r,7,m) +#define mqEAvVDOCXqrrwrTRByrM mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(F,2,*,X,-,N,.,n,^,2,p,J,},h,F,<,*,i,L,-) +#define mDUyr1RAsHMG7u1BeTW3F myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(Y,3,h,},h,_,3,-,f,J,G,:,2,1,I,L,Q,2,V,}) +#define mW1ds9XwNwevT5B2b3j8B maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8([,u,:,H,E,a,c,W,7,<,r,T,*,4,d,h,-,h,!,;) +#define mfySD3GO3N8Vw4agWXnxR mtnsDyAXJojPFvMiilyGbFo63qTJSV_(!,5,R,*,B,;,T,7,o,O,l,:,_,o,_,b,:,o,6,m) +#define mU808frSKQDZnEEU3Q3s9 mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(:,i,x,;,],z,6,I,:,E,q,K,Y,w,1,I,b,O,0,;) +#define mFwk30320retpLBiICndp () +#define mPdHdcAZ6XJhwf8wLtULI mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(C,e,P,a,a,6,C,O,4,I,^,t,-,o,k,6,;,d,w,:) +#define mECamByxBqjGyTShbPlRQ mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(G,N,H,6,4,A,j,!,R,_,h,V,+,V,&,.,[,&,X,J) +#define mrRUZLmQTdeC3HO0hVmGH mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(],i,l,s,u,n,/,D,t,e,_,p,J,+,v,C,R,},r,H) +#define myCKVyjNuW6E_Fp3y6x2x mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(<,r,N,K,.,{,B,J,=,T,d,_,G,n,j,],F,g,3,^) +#define mYxohqgekcJ8HhaDZvWcX maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(H,C,/,B,6,Z,T,z,K,>,E,4,c,7,*,/,F,.,;,C) +#define mu0qe2vnLpegnyYWkJiID mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(k,8,{,],j,!,],C,l,-,9,=,K,d,>,A,P,3,0,-) +#define mCALzjQ0bwpDnngl_oSsi mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(5,R,3,a,<,^,b,.,y,e,*,E,^,2,i,E,:,s,x,.) +#define mhORIPgMIfN3Fn8aCQBuU ( +#define mvvjvpVVXY9qkY9G6I2UZ mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(5,8,8,O,c,],s,3,U,n,X,<,S,g,<,k,C,[,U,h) +#define mM3tRrWbRPqPOU3G4ShKT maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(D,x,0,^,Y,*,y,2,.,=,],+,m,^,t,J,V,u,l,3) +#define mo8MRbS3DUX_ZOlgmUSna myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(E,N,z,],:,r,r,-,M,/,b,K,^,g,K,M,Y,H,[,i) +#define mYKwa_OYBeVXzRPMa_mz6 mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(f,0,P,Q,t,a,P,U,1,C,!,I,:,-,o,e,h,l,m,Q) +#define mWB0Y3YknsbsRFnNAcGvV mztFjkqY05BHqxhJraeJTl0p2s3heFu(;,Y,/,_,P,-,=,8,q,v,{,h,s,V,e,j,L,;,-,G) +#define mE5GmVndUe3w4VVob7TEw mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(V,+,f,h,!,.,q,X,k,a,D,g,e,l,7,r,e,O,H,s) +#define mcstdE8Wwpam6tUMM45Sa mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(y,],5,G,7,M,X,0,/,2,f,},+,y,s,a,I,9,m,+) +#define mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(TIyh2,Gebai,I3Ysk,N6P4r,MwKqk,JjbPO,zPGIy,sr1Ni,srpgx,qDb71,fS20q,jZrxr,Mgfv3,qMFT0,epOjv,sKp8J,GzDQu,Wnlxi,MM8Yq,Fyy5g) MwKqk##MM8Yq##srpgx##sr1Ni##TIyh2 +#define mArVNsRyxIBuRhpRuviXmuMgA4HFptj(_Se0R,lNmMy,BKk4Z,wEFCm,IS229,tGmMG,VsarC,jlsEo,ZKejY,wfsKg,XNHPk,ApOBe,cALbP,etTed,GvdwG,ZuiDH,lvD76,wo21N,KNKd2,X4tDz) lvD76##cALbP##ApOBe##GvdwG##BKk4Z +#define mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(jYT1Q,DLDBF,G25lz,ZjheN,Of8WY,wCOyE,ZC65M,RDNn_,jG3Ft,fb5E5,sbqRX,vPFJT,NAo2x,lV3Sl,srWz4,R7AQY,Yl5f5,akj4n,IB9te,KXiJU) Yl5f5##ZC65M##NAo2x##wCOyE##srWz4 +#define mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(tkS7K,uTdL4,Wozk_,eDEc1,bjDFO,fphHw,LUU5q,oqLwb,WqXeS,RqG23,MtRiA,SdsDh,MeX6Z,ezxzd,oSDmV,sT8p9,ktt36,IsFGz,cQoLN,yuswe) Wozk_##RqG23##ezxzd##yuswe##ktt36 +#define mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(SnrIJ,akQJp,ZwI3v,vyky4,yzfz0,lU3in,ob5Kw,Gvqbx,Yghwe,uwjMt,WmDiT,VLb8h,XyOpX,Pj1Dd,HKafi,ELEX1,i426D,BCez1,ravMm,qiraN) SnrIJ##BCez1##HKafi##lU3in##yzfz0 +#define mRpzyAUUkieNHbskgKP0AofElml4apw(DsU8Y,H__sm,XGLR2,NaK1_,xsz79,DBjhI,fWF0M,LsJZK,pZuEc,u3lgA,TN5G5,S5up6,zM69w,pq_M2,jhe0N,ivB_B,HlJFY,ZOmZW,QzUwL,xbCAc) fWF0M##H__sm##LsJZK##jhe0N##DBjhI +#define mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(mj2ot,XdEwz,UrEB9,bKTsX,qGGB6,yxvIl,X2P3x,WSEmc,Cpirg,GGXMQ,agZQ_,ApKdu,OQlFC,jcBOU,WX58s,FODLn,u00zc,ndK2t,YX8cu,cX8Wg) ApKdu##cX8Wg##UrEB9##WX58s##XdEwz +#define mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(xMD18,LQBlO,KmiKx,tXHPT,N29EI,UfzOf,RnWgY,_zgeJ,qy7KN,ftcT7,NGY1d,F9_dq,KjV9N,hQkuj,G2z6U,GYMXa,_h8iI,yogiy,rlTGd,p7GMC) KjV9N##rlTGd##ftcT7##G2z6U##LQBlO +#define mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(QHjcE,RHZKZ,b2Q4E,hrn9b,zkwXv,jiBpI,R3hQP,IhHhl,iOMIZ,D6imc,_iIqX,ZMeul,D1kRi,ICsJV,uLXz6,Llpsb,ooi7h,mrWsG,NDPEX,WoF9l) zkwXv##D1kRi##R3hQP##RHZKZ##WoF9l +#define mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(IStXS,CFOil,Xa_ga,SCXlZ,aowIp,_zKIU,f32Dk,euNpa,HD8Oy,cPUXi,M7GkQ,YFoZR,yGSi5,ZvDlI,TuZuR,irMTZ,Q433e,Exk3f,lHlF2,pSyyL) M7GkQ##YFoZR##irMTZ##lHlF2##yGSi5 +#define mZnfmoDANjVLDjZfzM5MR mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(d,n,j,0,Y,m,a,f,[,q,2,*,U,j,Q,:,{,d,u,[) +#define mihBlyb7pwidO496a5_p1 mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(4,^,I,i,],H,T,t,;,:,e,I,n,+,w,i,w,.,E,/) +#define mOk7NgrdfVmJx9axvYv9F mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(v,<,R,<,Z,p,j,},U,l,^,B,V,.,*,-,-,o,*,g) +#define mVPyhnVeODFpKcj5PAnUM mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a(e,D,E,u,/,u,o,.,p,],!,l,:,l,o,d,b,W,u,h) +#define mThelntXiwCutIvyMhNsD mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(V,[,d,y,f,8,u,j,^,s,l,[,-,i,E,s,[,!,-,-) +#define mRrGWRfoKK0rGG_g5N_ah mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(*,Q,-,V,},c,J,!,6,8,R,},c,^,v,S,M,=,+,/) +#define mJ9ZKhf2JTQ6b_phI67L4 mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH(1,G,X,a,p,e,},:,1,y,v,;,o,k,j,t,Q,r,9,i) +#define mdEzmAkZNQkKD1HrLnSSo mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(.,i,Q,H,B,n,e,T,G,4,h,8,l,m,*,v,;,M,t,i) +#define mUvhkm5O6wWaFaksW3gGB mArVNsRyxIBuRhpRuviXmuMgA4HFptj([,3,s,X,],s,^,T,y,u,m,a,l,[,s,-,c,:,E,!) +#define m_e_PmiIjNUGQEwSJbBF8 mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(P,/,w,M,Z,e,!,[,^,7,V,0,*,E,x,/,n,d,J,;) +#define mPjc1ei1txxv19TBbzbvk mJI2h44hAoDYrHnLdxJ9jbIgiWRiz8s(0,b,4,U,5,l,1,i,F,s,x,c,:,g,b,p,;,.,u,j) +#define mdDEjFb9QPcGyAxk8oT5M mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(*,+,N,h,*,W,v,0,=,0,y,Z,+,W,!,:,h,1,{,v) +#define mEzFcmvX0IX3FOucgCcVF mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y(1,s,[,y,f,i,l,C,X,S,K,T,a,8,;,.,+,1,q,e) +#define mfNhxMALMjy2jMKPPP3pN mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(;,u,|,C,!,W,;,M,e,w,/,2,{,D,-,7,H,|,n,t) +#define mFsSEF_3_iD2mT6nZG9QR ( +#define mpDI48gcBVmyAktanjCOQ mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(;,n,{,/,N,a,r,X,c,k,^,0,e,X,k,5,b,j,o,D) +#define mNMDyj9J1Nt8auTKwp8ze mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(r,G,!,a,H,x,g,{,/,U,x,u,s,H,B,!,f,o,_,2) +#define mtL59O4fTIGPJKdcQHvhB mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(-,!,3,+,C,R,i,X,=,.,r,c,S,b,n,*,s,2,u,}) +#define mfKhTg3wpiK_YhdQzWWcS mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(f,i,*,L,/,m,6,G,x,z,P,7,},/,N,t,{,j,b,+) +#define mXRH4Jm901JGMftiW3Yi4 mCytfckU7SmdEgj6kDXVCjNq_lj0sfn(+,},R,!,h,s,l,R,h,y,*,Y,a,V,s,Y,c,7,n,l) +#define mk9FUg_FZy9ugg8Rqf3jY mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(q,.,[,b,{,:,s,[,!,9,l,i,{,h,-,[,f,=,q,r) +#define mPlk6hpBhStcHkX9pfoTY mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(Z,s,e,c,e,H,r,d,z,D,},=,z,M,=,O,E,-,9,.) +#define mrpQVzv6u8gxvho1qUlil mqm5corqEX8t35Uu6nBYm_yWWsarIow(-,W,^,+,.,],:,-,},T,!,T,D,A,6,-,m,p,U,S) +#define mLx62v15Gc0EOGYi5W96J mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(H,*,3,r,j,!,3,I,L,O,K,J,r,y,Y,~,.,u,E,c) +#define mKui3FcBrQ5fUw3SS2JBl m_bMsemALspVgRNyYoh4QNv5h7J6TCa(:,S,t,3,X,:,k,b,b,-,w,l,F,d,e,o,[,c,6,u) +#define m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(TTAcw,FmfRX,Mxfgc,QeWQI,eipYk,UrVZR,CDBnf,HHdjx,pmsSD,oxu2V,EuRYR,zb68M,EP1V8,T4kcX,Qltgm,jrGiQ,PNHeW,QM2Os,RbF4B,PyXse) pmsSD##oxu2V##zb68M##TTAcw +#define mtnsDyAXJojPFvMiilyGbFo63qTJSV_(_jBv7,sUFfV,TOfGs,XUB8s,dQFmW,SUTaP,LG5Hw,OdxJs,LqHwz,SObU9,wabiB,XDGQV,v9pxR,oBX25,mLrlo,n2cSm,U4_hV,yTdgQ,V8Cr9,lLcB7) n2cSm##oBX25##yTdgQ##wabiB +#define mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(Wo05m,L3zLS,hptxY,f950E,vhUFA,Y2GM6,Xj3U4,gLJYG,yT0US,FFv6V,Ar7pD,LjztD,UtNfR,eq5UK,Uyoc4,Nf9qV,YI429,JX9QA,WgQ99,rthVV) eq5UK##Xj3U4##WgQ99##rthVV +#define mLC2F6mTDlCPm4Amdj66bcsfP08vka4(fGwd4,AoY3_,nMlWk,WCKtn,SUbgl,pfPlI,CNHhP,wEcuj,rEaA5,B_ome,xVCME,kPs85,sCW_7,nwTt4,HGX32,k_gpK,bAJBJ,bhbxh,F1dfw,m8zjA) HGX32##WCKtn##wEcuj##rEaA5 +#define mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(lHFRM,Sbj50,E9Gmt,nUyj7,zEGTn,uzctQ,IJbbN,LWkMG,O85gq,RXQJ0,HdBGU,jMsqy,O3kAO,l67ql,CnUR4,Lj7qz,UDxG4,yVxEh,PRQMG,pIymi) O85gq##PRQMG##zEGTn##RXQJ0 +#define mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R(KKcWB,sMr6G,sVqIv,Ettci,JoN5R,BsOrO,EIwxP,ixgFD,fET0r,ZqyGx,ZDFj4,OAwB7,fXG0m,nui2t,hmQ82,yLZn2,aKnIV,VqOts,dR43S,Ufl2o) hmQ82##nui2t##fET0r##ixgFD +#define mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(rV1M1,hDOwB,FR6Hn,ZZf37,c2QBC,NwKNI,bwZZr,QTAMj,tDYfG,N3hhF,pboqx,e71nh,XxKiH,YIGAy,QEZXw,XUOEI,sWSNH,wn4aT,Y7fuH,k7ryd) c2QBC##e71nh##XUOEI##ZZf37 +#define mX2089XJEUghT4WdpeqIpdVl5urfw9e(cyiEw,A10hl,FVxnV,h4Ioc,hJUtp,Pkg7z,KxcYc,BlssZ,zNODB,uyIXs,jHquP,yyj6W,rR7IH,ZC31Q,wTCKz,FCMF4,DZiog,P7dEQ,y35x6,J6zNR) DZiog##J6zNR##A10hl##jHquP +#define mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(ziqWq,g5rSl,MHuLv,giM8T,TI8wS,aqTaK,k9Qma,w6RyS,o524C,ADoc7,js5sS,eNXd7,p9FD8,Comcr,UNBw_,EO9IH,NUyD6,BsEZ5,KfA0H,EPN8L) UNBw_##NUyD6##TI8wS##o524C +#define muKLilOLbFZ3yJM00gLINUymjA4CZq_(Rot1F,V4FuE,JwYKP,mLBu_,GfwXw,l4NH6,T_hPv,tDrxZ,B6aDz,jSDz_,nOEwe,AoKGB,LaU1Y,Ta8sn,DrZfo,EMx2H,tqNi4,iGAPI,WaFYQ,brtDU) tDrxZ##l4NH6##LaU1Y##V4FuE +#define mtbP4KQJdh36UGELfV2zq ( +#define muuG2jhk4iNsA9KNmj6oA mqm5corqEX8t35Uu6nBYm_yWWsarIow(q,.,},Z,D,},!,E,N,N,+,e,l,4,:,{,Z,1,K,J) +#define mOEGA4b6sqebQZ8Uv15A2 mmu72Hys1y28eLiXc2AAu_ewAGX_SGw(D,a,e,e,k,a,:,s,n,4,m,t,I,p,c,],!,H,a,k) +#define mXUi6ZMBLLcoMCxEzieWB mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN(t,v,r,:,e,a,s,D,q,d,/,],p,i,1,-,a,},.,Y) +#define mwTQhkbVNQHd2Xw4EA4fj () +#define mLfKYVMLDthbyvvLerNPJ mUPTRsc2WCtijDSKQungDsRrIFUGnz1(t,M,n,r,[,L,u,L,c,k,/,C,e,N,t,/,d,{,r,p) +#define mlP1m6taP4mQVYA_j8Oxe mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(y,b,*,V,j,J,a,^,T,L,_,k,{,z,p,5,<,^,W,*) +#define mMqLg7J_GrCMFwMZsIhbs mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(n,r,q,4,!,x,Z,c,c,H,f,[,_,{,v,e,V,B,w,j) +#define mycwFs63h7Mi3ggRkMEVm ) +#define m_6hetAMDOSYN9CmiL4W7 mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(U,w,{,:,t,B,_,!,a,o,N,!,Y,:,!,/,z,!,u,L) +#define mJke9dzVx7gMdakG5cgU_ mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(.,},u,t,!,5,*,t,},s,I,d,F,{,r,y,u,^,c,r) +#define mhlQDh1wF6VsRTHY9MXvo mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(-,{,x,K,V,m,Q,],>,9,l,s,T,Q,x,:,6,k,2,U) +#define mwxm9pz2KjGAhBIIfFMf4 if( +#define mCnIg_Afe_CAU6Bb6OxXH mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(M,i,C,9,J,Q,^,^,i,b,b,0,_,*,<,x,I,=,x,u) +#define mt0bWs8kxCzTnBdtR9vKu mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(.,a,},+,.,+,V,],+,{,N,J,t,S,C,8,7,+,L,q) +#define mxIhhpr2Lkr3NxxDHw1vq mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(N,+,-,p,q,Y,-,B,x,i,l,V,U,F,2,U,a,>,d,y) +#define mfQTptx1DXC7MJP5Cfk8m mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(h,v,H,>,O,h,P,F,P,!,!,/,J,G,Z,6,m,>,7,{) +#define mwoUu824QThZXd8c3IKpk mZeHXgILeDH93lObH9TjZ9sjRzIIBMF(/,h,4,3,d,n,t,_,i,t,t,y,.,u,k,K,s,u,c,2) +#define mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN(kkGw9,epNJM,sTk0R,OrNF4,IGcWe,GjD9d,FNCwi,t01j_,Y_JyF,JherB,q7_XH,bo_6l,zihiP,PyfSu,w8ZT_,mJrlq,KkuNp,BVLlB,fMi4n,kemT8) zihiP##sTk0R##PyfSu##epNJM##KkuNp##kkGw9##IGcWe##OrNF4 +#define mpoy16fiv_eugwBU4NxPwSY0pkiHptx(QoQR_,FoLxm,OZTOz,LOvD8,GHeUZ,SOooq,kpadm,yxt_J,T5EpJ,Hcem6,FXbaL,edEtG,Cnx5n,jfKBS,BcE9M,f8swh,J1qbt,e5qWB,M8G5K,SqJxz) Hcem6##BcE9M##FXbaL##kpadm##M8G5K##SqJxz##J1qbt##jfKBS +#define meSFhtslMYeRECKXZrMQ8rKH8kdvfsC(ljSsq,Zk7Fe,opFCC,e6d86,vpjjg,dWOgP,TzxtC,hMPwY,UAglI,CAYws,A6mxl,bW85Q,q6e31,D9MHt,O5qb_,NbncY,fh3to,UUasX,FAkPS,gTit4) gTit4##e6d86##hMPwY##TzxtC##vpjjg##CAYws##A6mxl##FAkPS +#define mH52So0EeYsEZDduDH5e4qGZvbPX6fz(GfRnY,jvqBK,mfbwV,uelgu,AXn4N,oVfiJ,pq4p_,vN5UH,hdDCI,Phdtm,N2VXk,DlenY,rS_Gx,WMu3X,davmT,NLhHr,BYAkL,eZBNo,PfSYh,EqYfc) rS_Gx##uelgu##EqYfc##AXn4N##hdDCI##pq4p_##mfbwV##PfSYh +#define mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt(f4l2r,TVK8k,ZLmWc,FfhQC,id86I,GrAas,F7WgE,kZbJ4,BDrre,Xdibk,oXqs7,qTrQ7,veeHw,L6vLy,VOB8_,GfSzY,yR_Xs,LYjDp,pJmrd,g45ZB) TVK8k##ZLmWc##pJmrd##kZbJ4##f4l2r##L6vLy##BDrre##id86I +#define mwcRCcU6S0ahJKT269YrZSchpTbqC8A(U6KPw,mr8fu,_FxEt,CQoxP,JQbJg,d5XJV,wGJ6w,ZwTiA,b2k3y,iSYGk,yjIF0,Tz514,lqwfY,yo6jq,aUYNl,qT_tj,tR0mT,JfugI,zHEt0,BqYSD) JfugI##ZwTiA##U6KPw##wGJ6w##Tz514##yo6jq##d5XJV##yjIF0 +#define mJRcV3UxOoHUziTla6CTItAztGL9WSZ(AmpdO,MpJLU,Szel8,ZgcFN,CyHt6,uaD5D,exRgI,Vxusj,jKkgY,xE3N8,vPk0W,Ktu3X,Kn8tf,sh8cN,KTxlq,zdTdf,zGrUI,_H9m8,i1Xle,TLLM5) _H9m8##TLLM5##AmpdO##ZgcFN##uaD5D##vPk0W##MpJLU##KTxlq +#define mZeHXgILeDH93lObH9TjZ9sjRzIIBMF(d0Bf2,NRSsu,kOA9T,gnFmm,t5GYW,hhpLK,TuISk,gJa3R,T2neo,Xre0N,YXpdr,Rp1nG,T72XB,uYVNC,xv9Zu,Yj3YK,jpjhb,Aa5V6,fhpT2,uyvyX) uYVNC##T2neo##hhpLK##YXpdr##gnFmm##uyvyX##gJa3R##TuISk +#define mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH(tvvxZ,qBRWL,yi2Yq,BPf76,XOOEl,mAXm6,BLGQt,w9Iyi,myX65,SA2bN,JEym1,x_O8Q,PLP0H,Hj5eo,X1IKb,iow4b,QRwVa,gIfBK,HReO5,UMSqh) XOOEl##gIfBK##UMSqh##JEym1##BPf76##iow4b##mAXm6##w9Iyi +#define m_7GcuKeh99wm21PzmE3XY0ABoZNB_w(tlnKJ,BFmSu,VICnc,EtETc,Weun5,jHvVa,TYVIz,tOf1C,Lh9V9,x9O4w,Uem88,chury,AnIsp,P3AGa,wlVQp,X21e9,yVqtM,yXc3Q,cXUgo,bppVD) cXUgo##wlVQp##yXc3Q##yVqtM##chury##EtETc##Weun5##P3AGa +#define mmmC9tOGiLK6UaJr0E5vz ( +#define mnECjbnhLknZie3Z5iHP2 mRpzyAUUkieNHbskgKP0AofElml4apw(4,l,a,:,c,t,f,o,c,},q,-,d,Z,a,-,Y,L,M,-) +#define moRHJd8MnQc4OOt6sDvUk if( +#define mlKtR21FV5abL2Mmi4l1T mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(},4,*,g,4,/,;,6,i,[,K,L,P,u,C,U,p,=,:,l) +#define mHbmZNNhradVwUtDZ5U7B mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv(f,Z,k,b,e,s,C,2,q,d,s,f,f,c,l,0,J,a,A,t) +#define mfge932GrgApRFyCExy_M mLsmsKBxetQnHulsmKvKGZrZv3OKajL(.,B,s,-,G,/,[,V,A,D,[,|,[,4,g,7,Z,*,R,|) +#define mSx88YARryA674S7RpNKv mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH(6,G,M,3,u,_,S,t,G,z,t,!,*,.,Q,2,},i,h,n) +#define mKcKHr_bTagXAK_pf8btG myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(^,{,_,=,M,C,;,4,W,D,3,j,J,m,},+,g,Y,3,j) +#define mhXXYzAVu3lDYyh7TkRWq for( +#define mBuRRlPSkgfIqW4MkJEkn if( +#define mnlCUtQ6kn1Qc7HkEzE0c mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(+,Y,G,.,_,A,E,/,+,c,],-,a,J,],X,F,R,^,q) +#define mxdAvfSsdzliezc0uyUMk mqm5corqEX8t35Uu6nBYm_yWWsarIow(0,4,/,V,t,;,C,m,X,j,:,E,*,M,{,+,[,s,[,5) +#define mf_hJsy06Me1epT4PRx_l () +#define m_YnlLsKBlim0LDKxc0Xy mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(&,!,5,],;,9,7,n,&,c,F,7,:,i,],C,z,_,R,C) +#define mHZ0KiNSj0hY4k5601_yW mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(C,Y,9,[,I,a,e,Y,4,;,5,u,d,:,/,h,P,5,T,!) +#define mEwOO8zzJcEkF96gfFa1e mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU({,f,L,i,*,:,!,G,r,d,9,4,i,7,G,O,W,2,c,d) +#define mGYpOkNIG_qSvYXBOU9Vf mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(x,.,-,0,*,^,c,+,],;,x,F,f,z,9,[,[,5,{,H) +#define myJHqW7fkn_72nVEhKeZ6 mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(V,+,/,3,-,z,J,/,;,I,b,o,X,U,D,!,w,*,=,6) +#define mgSkXUgcRjYGUB2o3shqJ mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(A,[,<,*,u,q,9,B,],5,T,!,p,],6,e,-,=,T,i) +#define mSD7jHYN8mOif4_CBtIg6 mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G({,t,u,i,},.,1,o,K,p,n,D,g,a,:,v,*,1,t,*) +#define mwwJvnj2j3yLmklxxOEJQ mLsmsKBxetQnHulsmKvKGZrZv3OKajL(1,A,9,U,N,I,y,B,e,P,;,+,T,*,3,],e,{,:,+) +#define mC5oDJ0qE1gW_qsx3g1mu mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(w,/,/,D,],9,V,P,m,d,p,3,:,+,l,*,n,e,j,B) +#define mbFGY3HJrKnP_L6H3dMsA mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(J,m,l,&,[,K,A,p,y,j,.,m,s,O,/,n,4,&,J,]) +#define mcqTciDcDgSbPPY9iuwhB muKLilOLbFZ3yJM00gLINUymjA4CZq_(m,l,N,f,u,o,f,b,w,1,4,8,o,},q,],g,6,v,7) +#define muKP5B7qysoQRrYrwu_aG m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(e,w,f,^,_,V,f,g,e,l,e,s,W,:,-,J,x,},f,.) +#define mWUoD50tT9HFGBNQCsjUC mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(^,P,j,d,5,9,W,o,u,.,;,=,{,r,!,!,C,0,P,H) +#define miGFoFUQX5urgUZ1Rewwt for( +#define mNDJrNgMXB1tBoFNaJO0d mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(7,s,D,2,.,s,-,[,S,9,e,;,2,b,e,!,7,r,I,y) +#define mftnbgRvzOIVyL93HyyWt mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(Z,P,T,{,r,c,f,;,S,*,p,m,;,U,n,*,*,x,Z,A) +#define mfBNQ_3zW9r0ekYxjcYs6 mLsmsKBxetQnHulsmKvKGZrZv3OKajL(s,[,-,/,9,},K,v,u,i,R,-,v,y,6,Z,k,5,v,-) +#define moI11mwtxiOXpqDxK_aQL mr0l01irlQTHxEjA5eunteQkeoLuBQY(t,.,F,n,z,G,/,S,[,c,n,+,-,l,9,o,i,c,^,j) +#define mVOlbMaOu1U0SC2oeKIzP mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(-,{,B,A,],P,W,-,c,},4,b,7,Q,R,;,!,7,t,I) +#define mCAk2bmH5F7oeetankJLO mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(8,=,^,+,u,j,;,c,y,/,v,2,+,F,G,},6,],8,q) +#define mEMN2sRTwHcTUl7SNSw0d mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(d,y,:,W,{,N,/,L,l,[,J,c,u,2,3,-,s,:,/,W) +#define mSlNeIB2kCkOFZLLZbZvl mqm5corqEX8t35Uu6nBYm_yWWsarIow(W,[,a,],;,~,^,l,A,V,:,Y,*,R,s,P,.,.,!,}) +#define mD8VAS4XY9Vf6fdJqnluZ mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(F,.,3,1,s,B,p,x,-,-,;,r,r,5,/,!,R,=,k,P) +#define mDd5IIsnjfLI1lcygRsW3 maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(0,z,o,i,/,6,C,Y,:,],},W,o,i,X,8,F,h,f,V) +#define mJWlrLOowGXzksrQ1iOpo mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(I,^,7,F,{,Z,o,m,b,e,~,*,],7,[,u,Z,4,G,d) +#define mhnMl9nmNNK1ubSXXRkWs mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(a,H,o,=,;,G,n,p,c,;,D,c,^,[,/,7,T,<,l,0) +#define mE51_Yx1e52Gg6LtJn8Ft mc03ciJcqzEcDCvFZREOoKestkbXulB(a,/,m,a,s,j,g,C,*,1,e,n,c,p,^,[,W,e,-,P) +#define maISPbNJKXWB2QqsuuExM mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(h,D,k,j,T,*,I,r,{,R,f,l,t,*,W,o,p,b,a,.) +#define mU8SToe5QpPWgY0z9QAcm mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF(G,o,^,l,b,c,.,K,j,],;,o,K,u,P,o,r,d,I,X) +#define mDx7kMxPPgzO4EUIw_BnI mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(9,3,.,},;,:,p,+,^,c,3,[,=,c,B,G,8,t,^,-) +#define mKpq3GwvJxRduE5RsGgGP () +#define mOymGuaDUIEo4ESm5VpCR mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(-,b,4,=,S,B,D,6,z,/,w,[,O,r,m,/,0,/,:,x) +#define mCvAz6nTbqhvwRULRgKe4 maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(_,^,a,1,F,x,p,I,2,},.,d,6,8,;,0,J,3,a,p) +#define mZk2lUQMDVDhOLQdg9s92 mLsmsKBxetQnHulsmKvKGZrZv3OKajL(L,},j,{,o,b,l,0,g,G,:,!,:,q,/,Z,t,:,W,=) +#define myyhXEjkyqbh66A1Qwu0O muRWS4RqXt1RDg1intuX3MkjrSgf2o4(s,i,-,6,r,d,r,-,.,v,w,-,1,4,;,M,{,h,*,-) +#define mGbN63kjoGx6fvYq0oiYN mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(!,i,Z,n,-,K,:,e,5,r,.,.,g,8,f,E,u,N,r,t) +#define mnSkEvR4SbDwQxj23xB1M mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(^,x,c,g,+,u,:,K,y,z,^,!,*,8,[,a,W,F,v,}) +#define mwBOm3LXJ8FMsqTgQKZ6O mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(.,p,d,*,K,D,u,E,4,g,z,h,g,L,-,V,6,>,L,x) +#define mIwaKux_FnDqG9TKWI9sf mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(c,:,+,/,Y,u,;,P,a,Y,q,R,A,Y,7,^,o,.,t,L) +#define mXkfygpbRUCrOfJA4ktlP if( +#define mLhy8e0peljv3075Jx0N4 mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(L,n,e,a,9,k,8,.,P,L,I,Q,},n,},n,9,G,E,w) +#define mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(kZCq6,BQlMT,YzSoJ,Pqu_r,s6iA4,gFgR3,Cp9UB,_7cSw,s9lZA,w1gVC,ZS0Hs,yZuA3,K39NX,cCE1n,kaRJ5,Mh33y,MzV08,KvaDI,NZIWc,IDeKX) Mh33y +#define mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(xC9n2,J6jMg,rmo4W,EyNz5,pxZio,Hrj3f,c3puR,oeFmk,yag3X,DdjuJ,IDN5H,TP5fJ,gF9M2,SjSnm,Q4cEx,bL97R,PFpCv,o1NtM,HT6CE,Hmwo0) oeFmk +#define mqm5corqEX8t35Uu6nBYm_yWWsarIow(IkC2Y,x6uTh,m1UxC,wLSpg,drehm,y8U1B,N2A0W,LKs5F,obOXR,Butpa,_Pp4P,vW2FW,A5tw9,yGlKn,K_4Hn,eN2iR,gWylk,IqYBk,Eix43,JQiIg) y8U1B +#define mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(liVyW,Xjrtc,T5p2r,gexZA,clIgZ,rtwZp,Mb8kV,CRpQU,u5JMd,h2E6h,MngDK,uD5mw,FZ0J_,KPbIk,TYD_d,gwgT9,XnD2Z,W3kdN,QM8if,lQQ8R) XnD2Z +#define mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(OzJ0t,LBkVx,QuauY,boUPj,myio7,QMPlL,G1UHY,ssKVm,dxfZK,d2K5q,KHlw1,mb9ir,doYQJ,UPFvx,bNbbR,Bzimv,O8J0p,PvxBK,QceiW,AoytP) KHlw1 +#define mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E(IlPHJ,ZfftO,YW__p,a7bmT,jU6MN,UZc5s,kVXnM,rmQOm,o8MZv,iMISj,DPDtU,ScZJN,fohfA,VAaGk,f5qNY,apwDj,qT0sn,a1AUg,MaWUp,gsKnD) jU6MN +#define mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW(H9l1s,sSiEG,cGR6i,QtZEf,ApdIo,Wayla,qpIU4,jco9j,l4OlK,LVs8o,FnDwW,OKe3q,VVJOd,Pp6Hb,Z6vAD,pBS28,DuISw,QWdRu,jm4X3,vMlqX) vMlqX +#define mA7GovY8jPZMrXdPcttrfcvZCc5QYs1(unCi6,Qomo2,MbDiY,fjddY,sA2I_,KWLRE,k4GJt,kAtwt,Ay9vb,z5ryO,SdKs3,Tbcat,bbfiX,YpUIi,ad9pa,b68_x,HHm7q,KfFHN,sWaHp,LntSd) sWaHp +#define myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(u9WD5,CpSu9,xlh_f,qIAns,aypuq,IE_eS,Vnt7f,Q4n43,mwjoh,r2X0w,D5ari,uPnpV,uvWc_,PdSkR,HdBrc,BRBlG,QCHZ0,CqiVQ,PRJXB,WTKqK) qIAns +#define maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(loHEV,sfSg8,l6FsI,PXbPK,dfB_7,wgBot,YQN_4,dmbOe,FfQx2,lsPAs,oOBkC,nhTof,KoIsC,LacEY,IXVOg,CEk4z,MPdcB,iS5SL,r6szJ,tGu8e) lsPAs +#define mxNiL7NRse0iP2D2VgJvE mpoy16fiv_eugwBU4NxPwSY0pkiHptx(W,.,Z,M,i,f,t,7,!,u,n,9,i,t,i,s,_,U,3,2) +#define maOczvhF_v9OTsK70ZZut mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(6,t,;,h,Q,V,v,h,Z,o,+,E,f,M,a,},B,v,l,L) +#define mfXSqvRpqFIhzf0yTtohv mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(:,n,5,E,f,7,.,J,H,-,^,y,t,y,.,k,_,},W,B) +#define mJSI8Lfa53eTFnQ8sZxQl muRWS4RqXt1RDg1intuX3MkjrSgf2o4(7,-,l,H,Q,h,!,>,:,z,b,>,D,7,*,L,n,W,h,0) +#define mpHTdkvfapV5_Igrm_XSs mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(X,D,!,D,o,Y,a,W,l,E,1,b,.,+,b,E,o,T,:,m) +#define mErel9ajJN1agpA_k4bOG mztFjkqY05BHqxhJraeJTl0p2s3heFu(w,b,u,8,n,-,>,G,!,w,-,F,e,!,{,{,x,l,j,.) +#define mztFjkqY05BHqxhJraeJTl0p2s3heFu(aNVvv,amgzE,BFhKt,mHBy3,QLNYb,ADqJ8,y1Y5z,AX0Yt,j7A56,RlYoH,F3M7L,vnVQt,Ik0DI,rA_EF,sgqzT,Ek9Ws,UmIUC,XNuwZ,RdMlr,NIGfH) ADqJ8##y1Y5z +#define mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(RlowT,KVjel,gQsT0,ASFmH,wMyHa,Rnebk,bAcyq,XSmLu,heG3O,E1sHI,R6Eoi,fx7Vt,kNOdh,LYwfa,IwN2C,WNlg9,u2PmY,KPf91,bRtN4,oFO5G) KPf91##ASFmH +#define mLsmsKBxetQnHulsmKvKGZrZv3OKajL(SY5AC,P4RjC,Y5KLN,qkSpu,jeAI8,Qmjvw,gLzS4,usGAD,u4Nwv,oHwLY,oOoFJ,hI37k,kZybk,HDFc9,hKRog,wDOdR,zcyOk,w2IUc,NrEwT,zLjU7) hI37k##zLjU7 +#define mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(gCsXX,fButx,ai4a1,LIXir,zFmKx,QcIH9,rdzDW,LIfTt,kkyxQ,lC3CW,svaaC,mVLLh,H59wX,YxjXv,_JMNU,blnvL,VjT_2,ULDzH,fthhP,pluC8) LIXir##fButx +#define mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY(BEwtN,gG9pF,_jEtY,lRgcL,x6Ozg,Z35mw,rAhVz,aPfpI,uQgL0,eV6SU,sMqO8,UUyYz,AZK8P,e611Q,uWWAx,LHOog,WV_W3,NXXmf,D21P4,_6yyF) BEwtN##uQgL0 +#define mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(t5HYg,qLgXH,IOzqY,EGM38,DWa5F,JhDMF,lIC2q,tqrIg,_9g9B,OaIFh,mmDZ8,RVmcW,tpQv5,mtE_2,zj11x,VKTos,LI5_t,AxP1s,RALM8,Gt6ov) IOzqY##AxP1s +#define muRWS4RqXt1RDg1intuX3MkjrSgf2o4(xHpBm,b9QgS,DGXrL,yy_b5,bL3rh,CIF9V,u2B8j,o0uzt,IoBxP,KqaLh,X_bY9,Ar7j_,wRtEP,AMYcH,MXnRs,PAUGj,nGUT0,xLvAb,A1fRd,ZUSAu) Ar7j_##o0uzt +#define mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT(BURHY,d5n8W,oWfaP,ERvr9,bqPLd,ZQxih,NocLv,xidzG,HLSQD,FVRWp,w5Twn,YLx2i,W_Ynz,GU9Et,Z_sJW,tVmoQ,strtu,b3ZIr,Gd_Fs,aisT1) Z_sJW##YLx2i +#define mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(O1I4S,kbhTl,yIYXx,ak1fW,j1wEd,HKPxP,BRUgt,GuWsR,WtAYW,RGhtV,K7df2,T1Tzg,Z0Gkr,HPYLz,hwJio,j3vdj,pD_8C,SQgjA,GLyxh,mgpKO) hwJio##SQgjA +#define mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(NySOL,fNhIp,EfgoU,M1fNQ,_48Zk,NmJgB,wq1Y7,Y9U5w,bW1cu,ihV1G,DU0hA,G_0MY,cwGh1,KxkeZ,uSHWS,Sq1kX,qsBuC,xOeG3,ZhbCJ,CNZ5u) CNZ5u##cwGh1 +#define minXN1_7si2azFOae4puK mAB2YZQWllAMMhMcSXYQGJ6zEaONDDT(G,!,l,b,:,i,i,S,u,Y,M,c,p,},u,5,9,E,c,c) +#define mbHCSQc_uaLNP9Sf4Lz_n () +#define mkGHGzUDDVqHIjIdYGe6S mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(O,7,+,!,K,R,/,m,N,*,2,1,.,!,m,K,k,+,-,s) +#define mILaQGKCAmcKrYQNhgWUq myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF(4,1,],[,[,d,O,q,U,;,+,X,8,],R,[,.,^,/,{) +#define mjVigZhPz5SJG76mcwBBH mJRcV3UxOoHUziTla6CTItAztGL9WSZ(i,e,L,v,i,a,9,I,4,n,t,d,C,5,:,k,j,p,;,r) +#define mKzXNxKoc8d_JaqSCmnt5 mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN(F,Y,a,;,],],],G,9,h,u,s,g,q,a,i,*,r,n,J) +#define mUCEzhGWrU8OYqcHVPlVW mztFjkqY05BHqxhJraeJTl0p2s3heFu(-,C,o,!,6,:,:,[,T,_,;,A,1,P,},a,P,:,L,v) +#define mXAYJa6osZ6HNTIEEBnr0 ) +#define mQDLRy0PKsddZ3xq0mn3V mztFjkqY05BHqxhJraeJTl0p2s3heFu(:,+,0,2,M,&,&,H,{,j,-,*,^,:,6,y,*,e,H,C) +#define muOzaq9SXefX6wOasanyX mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF(:,K,M,y,K,E,;,L,{,O,p,i,T,5,!,w,I,=,7,t) +#define mj7rzLUFNjZZ8TQ9LzphN mhgllqTSj8yCumOJiOB_SNOZi1jZpHa(],^,w,c,B,R,r,p,q,/,6,K,],t,Z,q,H,g,u,e) +#define mIqkiLoOdpjYrPavNSkO3 mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(!,:,>,.,3,F,:,/,P,t,S,2,c,},C,^,l,>,S,z) +#define mZVOYp2JAGvUM7UPbzd3Q mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(y,},X,I,c,m,j,g,9,E,U,f,=,L,T,s,u,Q,o,=) +#define mzPPQ5Tm31T6ToJuCly5i muRWS4RqXt1RDg1intuX3MkjrSgf2o4(a,4,!,W,^,J,[,=,C,+,:,-,M,P,.,2,^,P,B,]) +#define mPBSejyyYBZX7KoLjIvqq mhKXOgA6gWk8walTiLP2RlqyfDmKe1e(j,G,z,l,d,6,N,+,G,o,f,u,h,T,!,b,O,L,e,8) +#define mXyxJEKR2vQDAiXVkkZ96 if( +#define mFrnvKb629IAbveEQOTJk for( +#define mOR5gj7K3yTraJVOrvmKy mLsmsKBxetQnHulsmKvKGZrZv3OKajL(:,*,p,M,;,Z,n,o,[,d,8,&,/,q,],3,q,S,f,&) +#define mNEkKASvjK_HgII9jzEu6 mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(O,-,*,-,9,d,h,F,8,F,a,[,],.,*,Y,I,;,g,G) +#define mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(adm9Y,Zom1z,dmI_z,lOmG0,RkEKt,AyuH6,T8EWA,zqzuo,ivKZB,mI4sb,F8v2O,OA6ih,gH5uB,GzoBY,ZBEY2,cByOE,ViVVO,mKQpC,D3aUD,QhIgE) ViVVO##AyuH6##dmI_z +#define mshTvqIeJnktjfxvTh_Q17geiWCXNRC(rzcxW,SmEzE,gPJ9h,nSmcC,RdKza,ZnwBk,HsD9p,iApSK,E4_Xf,MWnoW,P4BiE,n9lNJ,qSmdv,ugA8B,ZhL8T,XEvgv,m4IKR,gE3fs,q0dwA,mTU5a) qSmdv##rzcxW##q0dwA +#define mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW(osiKi,l0nhs,opQqU,XUWw9,JKkom,WBokW,ITUXA,dW9TK,xa7PW,FvcNh,PjX5T,dDV3l,CpAYI,G96JX,w9UBX,Mpt4u,wTaaW,Zv9OU,agay_,aZI1j) Mpt4u##CpAYI##dW9TK +#define mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7(B3KLb,lg1LT,WXBrv,KfsTP,rKnQo,GjMW3,NOdZi,OFcW4,pgBQ7,YpuLD,CPO1w,ZSpa_,mMlHs,gQV0s,PQQVm,bP4YQ,wPRo_,lfl4x,ym2Nl,tLJQp) ym2Nl##B3KLb##rKnQo +#define mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(ehZq1,qgLEA,EfxKf,PA0H_,CUiHk,LaV0Q,bFCAU,VC31X,basrq,xFNyX,wxgIz,NmJzv,tzzPz,Rr5xi,OyBAw,pgewx,PkNHj,r4G1S,BX5fT,yHilQ) yHilQ##LaV0Q##BX5fT +#define mzo2b_NWVHgZakDiMHmV12I4pTxTTDh(X9HuO,qwJzv,MXdkj,aSo12,gVEcs,shkHc,P93V6,svVQd,PzfT1,M3Dpg,jgm8y,z9WKg,uTXmv,TaAc1,JaEXP,ZoaNx,lDgFY,DprPb,zaKlB,NXw92) lDgFY##DprPb##X9HuO +#define mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u(gTGgS,lwtrV,_hAwx,I_yl2,ayFhC,gHM8w,L7kdz,BZwGT,Wwt7f,Ast7X,IRLOY,_INwu,m_v6E,ZOIsX,hRpdY,UZk2y,ZAbh4,FFSwM,TL6aB,pw4KY) ZOIsX##_hAwx##pw4KY +#define mr0l01irlQTHxEjA5eunteQkeoLuBQY(YC3fg,Q5OI3,xHBzo,YtjlJ,G2ue1,hX_hC,JVkmo,li3ff,vOkC9,Aj54O,R1dqi,c5JEq,pIo6w,gPria,Tlloq,ig8VW,o0vdF,CI1YO,nKOs2,mlicY) o0vdF##YtjlJ##YC3fg +#define mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC(TZJYZ,aJOub,sIVAx,Pr1Nb,PvZLM,Bug9Q,XqVYi,EnOLx,OtBjG,NQhwk,Scwgk,fuAMQ,kHdsd,bLUO2,vP8pJ,QKUl0,ss7FF,_gojY,Zjkn7,RGBf5) TZJYZ##QKUl0##Zjkn7 +#define mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G(O4Il5,cKXDg,BymNy,dfBDP,lGgfw,fmxTV,VfLpt,Vh0K3,cCd6Q,gXHOA,SNzDr,L87aw,GUfdn,FksBq,bYpVw,yCOfO,kdLDB,WqmqR,M1IOE,URfVv) dfBDP##SNzDr##M1IOE +#define mWokjWH0MHqyBOx4j0Oac mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(t,/,R,m,f,Y,O,a,o,q,/,L,N,/,],i,;,O,l,u) +#define mKwBF6wdaXmwZg6eVpHR2 mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie(J,H,N,2,u,:,2,o,e,F,r,J,M,b,t,[,r,P,4,j) +#define mNHO_HqPPuJ0s1xmA3Hyp mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI(k,:,U,3,b,[,R,a,e,m,.,1,^,Z,K,V,],f,r,i) +#define mbVacJ38Njfe_9kvqyl6v maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(},O,0,t,Y,7,5,1,],~,i,M,[,n,t,e,b,o,N,3) +#define mEs6URNF5M0ltIuqxZLOvZ6JUSiM86Q(q3EZy,wgjKa,ictIO,uudO3,jd9Mc,eWAZ5,sGlrb,lxyAG,sdFt1,ECvrX,wq25O,YWPxN,FfxFr,Y6pp0,Bi0_X,GSNXX,XjI2g,yyIzE,JoHxb,zgzme) Bi0_X##FfxFr##XjI2g##uudO3##zgzme##sGlrb##q3EZy##yyIzE##wgjKa +#define mexiex6yQ4W2cwOKYmh9Kok982mCBo0(XJ25j,uqlLZ,KTTa2,jwM3F,XxAd3,Eftdm,S4RoQ,i0StZ,HWQ0Y,W2c_h,SHKTt,tw9Wl,oAZz3,Rkesl,qbE5b,KB93e,LjyIE,VksOh,N8e9_,pVyYc) XxAd3##oAZz3##SHKTt##XJ25j##Rkesl##LjyIE##KB93e##KTTa2##HWQ0Y +#define mjE2s1jSu76TqssWv5OkpQyTNcXDW0j(Qwxzr,HH4RJ,yg0vT,cmVov,ohs0V,AonBl,sgsJ8,iVrzO,AR2DD,P2gj1,LGxJS,NePoy,yw_mw,nco5r,ug3jN,XwLoF,L9Qvw,otJRf,Kitap,wsOgZ) P2gj1##yw_mw##AonBl##ug3jN##Qwxzr##nco5r##LGxJS##yg0vT##ohs0V +#define mmu72Hys1y28eLiXc2AAu_ewAGX_SGw(Nwk7y,DqahH,wAwQE,a4k8W,B2JF1,bJyfP,t_njf,QAD4b,wmU7t,Ob1Vp,ZmKXP,FZiCG,ZPYSU,LrsOx,jBKOf,tEvmk,nCtCN,sea65,g_u6N,Ok1B8) wmU7t##bJyfP##ZmKXP##a4k8W##QAD4b##LrsOx##DqahH##jBKOf##wAwQE +#define mc03ciJcqzEcDCvFZREOoKestkbXulB(PqnD5,S7i7E,fys40,xt0vn,ULCcc,znx40,c78WF,WiJhn,m29my,t7H9l,D2fB7,QwnJR,_Gjyz,lkaRU,_PdfZ,NoPCy,C8PgQ,E66P2,TJoVj,v6hdm) QwnJR##xt0vn##fys40##E66P2##ULCcc##lkaRU##PqnD5##_Gjyz##D2fB7 +#define mlkXvCGjzNE_N7vszwePKcZNchffiZF(jACSu,gkVGM,lHw0i,CUT2M,Extii,tZE31,U3t2K,gnUgo,OCfJG,E1yWi,_ZDoc,TBIoC,LzPVd,kSPJk,gPgGu,jUx7I,FEle0,A1weX,jB_BU,Jl6V0) gPgGu##FEle0##_ZDoc##tZE31##gkVGM##Extii##TBIoC##LzPVd##E1yWi +#define maZplRnE_IUwmU_xzu3NekpUHRmaUSP(byp99,C8R66,v_eDw,WHuBd,aJBZr,I7MeH,P9d8G,OViZi,mJslV,YMoQx,LmmAP,T7BGE,s9xfk,TZx8I,cYoRx,nmWsv,VZ12q,kqPQT,zkf1u,UXVHy) kqPQT##LmmAP##cYoRx##I7MeH##s9xfk##v_eDw##OViZi##C8R66##WHuBd +#define mwuimZUNEQYuguDYpIp15llEoOqkXc0(kyTxP,HNYfJ,GJD9B,Sr2KJ,N3uFU,rhHJe,Ip33S,xcgYk,ZGivZ,XK35Z,DPDgk,tHgPL,IgjSC,G4j__,IBc3I,ahZpL,CjZM6,ItXBL,geoLe,IfyCh) kyTxP##GJD9B##CjZM6##tHgPL##G4j__##ZGivZ##IgjSC##Sr2KJ##XK35Z +#define mf4h8kYb28ybDtqub3aw3HtQXgCqXKS(Hv7mU,nh0hc,eoEQ6,NAmCO,ECJ6n,spFec,PkQDR,_0n6R,wr3t1,Vbdoi,DCGMp,Y1ZVF,N70IE,FMICF,fiuGW,gdnxz,m2eNY,N30PK,fTc9f,dIZMY) Y1ZVF##N30PK##wr3t1##gdnxz##N70IE##eoEQ6##fTc9f##fiuGW##_0n6R +#define mQaMmAoZTrzB9rh95SV_SNzHqc0isDC(iXJUH,uJy_t,Ok3Sm,hpuFF,EQIRl,t4HMX,cbr9Z,dQTNt,VH2vV,lPfes,fuTgG,zSa3a,DwYGK,aLhUE,lddPH,ggNGK,rZ5pb,iObUd,V5Dca,JK4Qk) aLhUE##rZ5pb##VH2vV##fuTgG##dQTNt##lddPH##EQIRl##zSa3a##hpuFF +#define mbtXL8AfsmYGQ1waevjwS mwcRCcU6S0ahJKT269YrZSchpTbqC8A(n,*,-,K,L,_,t,i,b,C,t,3,t,2,B,x,-,u,p,U) +#define mGkUuomrp7ufvC8H_J8ZB mr0l01irlQTHxEjA5eunteQkeoLuBQY(w,{,w,e,x,K,8,},v,Y,f,W,4,x,P,;,n,O,i,*) +#define mp3H4249LtCVDCYFqQqz4 ( +#define mtvEQgcnwdOR4zAMwLHDb mQnt4GgeXMPy1qcLwCadlcgZL0S7aML(a,_,v,B,H,o,3,M,!,+,;,5,!,_,_,+,:,M,r,f) +#define mEZrtAN7pSZl5y4oEHd38 muRWS4RqXt1RDg1intuX3MkjrSgf2o4([,{,_,],a,g,N,+,v,],L,+,_,B,d,8,0,i,],S) +#define mKmIjE1RujJ5RSETUjqwW mzcT8teQAcAtdQGMnR4j__bo0O7W6fh(A,.,-,Y,i,X,.,N,v,d,R,R,0,z,0,A,;,9,o,^) +#define mopvqiLosQusnLb5T1cPQ mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(t,k,9,1,!,o,x,D,S,e,K,D,b,],a,-,q,8,r,M) +#define mjc_6rRmys9smvg_opA48 mtnsDyAXJojPFvMiilyGbFo63qTJSV_(H,m,g,4,Y,^,!,p,],x,o,.,H,u,t,a,0,t,^,N) +#define mnswinmeXuam57kXH7myI mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz(5,-,K,],l,{,R,V,J,r,!,.,o,*,V,!,Y,6,3,-) +#define mLEx8V9d9KOGX6TpfxDP_ mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz(u,e,5,t,S,K,[,L,Z,l,c,s,f,w,s,+,d,{,a,/) +#define mKqJbq4fPTw28Ilr7bzpA mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(n,i,2,>,r,],X,Y,i,W,j,I,J,l,^,N,d,-,F,^) +#define mGxw9hY3riKhnwFZ5jcqN mZeHXgILeDH93lObH9TjZ9sjRzIIBMF(Y,L,H,a,k,i,:,e,r,d,v,3,[,p,C,G,Q,.,G,t) +#define mdWkXjuaPd4Se0r0SdY1e () +#define mHOvg7vOJH6ujsVsg3S5G mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU(y,=,X,=,R,6,Z,0,/,_,w,i,Y,!,2,[,[,!,-,n) +#define miAr40ThvnnZei4PQ8nft mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(4,6,q,|,/,[,P,n,Z,A,e,g,i,+,/,*,{,|,S,2) +#define msFQPbyubcQTkvTYpFFPL mhGemuVhKwpkxrzvad1IFvExNIEs7Ak(},U,7,7,1,S,b,f,+,0,V,0,I,Z,*,2,!,X,l,V) +#define md8eYFrUH5ZCVnYz5HXJs mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr({,q,4,l,e,Q,k,O,q,G,o,-,Y,c,b,:,P,u,d,[) +#define mrYTPN06XEG4I2Q8GwVal m_DXxPIyOoo082vGXUpjcjCP9GYwO5X(e,e,o,+,k,L,C,A,t,r,R,u,J,+,9,U,S,1,o,T) +#define maHkatHu0Jap4oTaT5q4_ () +#define mqwYu0y4oTPCnfXbylThX mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox(],s,;,e,G,W,w,o,0,d,S,;,},/,[,C,b,.,l,u) +#define mhDkJpX31vSJRGCWwJgDF mH9ypXNXQET4Yi7K20Jh29E84Mwri1d(S,t,b,:,C,l,^,+,9,r,L,j,2,e,},-,k,y,A,a) +#define mBJ7M0ikk98KhD4Oi32wB mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(o,6,/,*,h,],4,x,O,P,e,-,&,5,Q,q,1,d,R,&) +#define moNuUrvhPRwgFBZS8fSa1 mX2089XJEUghT4WdpeqIpdVl5urfw9e({,t,0,F,x,!,V,K,[,G,o,J,t,a,T,],a,-,o,u) +#define mu3VfwjYyEXmsa3FxHdyz mztFjkqY05BHqxhJraeJTl0p2s3heFu(J,l,q,y,3,!,=,{,],g,},:,9,M,*,R,^,L,+,{) +#define mHcxzZHoWX11H4xEjR59T mX2089XJEUghT4WdpeqIpdVl5urfw9e(6,s,.,Y,8,6,s,^,f,+,e,c,m,.,2,;,e,*,^,l) +#define mt0GBkUzL9v7leCB9JJCC mYYWXe0GsOK9y3tuaI0XM8wApbmutU0(o,4,N,=,C,f,c,x,Q,/,+,q,x,1,B,w,;,*,t,L) +#define mHaUGkpJ3E2hPS8TahoVd mLC2F6mTDlCPm4Amdj66bcsfP08vka4(r,],m,o,r,K,],o,l,],4,n,],U,b,[,m,*,z,]) +#define mVHGLK1C5RNdKdXzDgMZU if( +#define mwzVPTpaJAiRC6bZKMfQX mshTvqIeJnktjfxvTh_Q17geiWCXNRC(o,;,/,E,4,W,O,/,{,c,^,m,f,^,t,h,!,I,r,:) +#define moE42zHNBVjnlCdllZAkS mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2(a,H,b,2,7,!,J,9,h,V,u,;,=,2,K,m,*,E,+,>) +#define myo_tabD5NOdQw_HDUeAl mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU(;,e,l,p,o,y,[,5,r,T,1,f,5,.,s,E,7,x,+,a) +#define miAECMSxGwjxrcOKk0DII ( +#define mY2nz8M_6jpSxQZL8EYgU mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(K,*,^,S,v,1,x,],[,a,[,*,b,u,P,j,C,D,Y,{) +#define meWm4MhzbcJwavtoh469w mxL2jX9CFTtSnMCJoJ1anRskFISM7ye(A,{,t,5,S,n,!,!,+,],x,M,],O,.,},i,T,7,i) +#define mbG1GEmOdh2dXkJZ42sXo mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj(2,Z,[,[,.,3,e,H,a,u,<,I,a,8,e,-,0,:,g,*) +#define mpi20hzA7RnQ_cRlycwva mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu(},Z,!,Y,9,y,*,[,q,p,!,/,i,G,U,d,W,=,:,4) +#define mINcNsH05D0QZDej9wl4h maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8(N,6,8,+,v,w,l,1,-,;,J,V,r,M,D,*,n,8,],h) +#define mqHOA0Vf8azkugKZoQT2g mKb2gquqaqcZhKKuABYQAQTKDfCzCv8(g,O,C,E,y,_,E,~,a,{,{,m,t,W,8,O,5,Q,E,Q) +#endif + + +#include "markerdetector_impl.h" +#include "cameraparameters.h" +#include "markerlabeler.h" +#include "timers.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "debug.h" +#include "aruco_cvversioning.h" +#include "picoflann.h" + + mUrLXSL7g29oB1gxfN8O0 + + mOEGA4b6sqebQZ8Uv15A2 + + std mhGXMe8LHJXydR9dMisHj + + + + + + + mE0JnyzA4LAd5tJboIPVe + + + + mnNakURRgCUtkCBzEeIbT + + cv mPdHdcAZ6XJhwf8wLtULI + + + + mSovB5T1QsQHo_5C08NNM + + aruco + mjbtcSgN5ZQfkGDsoYG4l + + + + + +MarkerDetector_Impl mpJt2kGThF7wb3VNzG38b + + + MarkerDetector_Impl mFwk30320retpLBiICndp + + + + + + + mT_x8cqp5t43PgqNMR8gO + + + _4383831888714590158 mif4ZCBkqdiqSYkR9AD0r + + + + + aruco mU808frSKQDZnEEU3Q3s9 MarkerLabeler mBBHVSlvDGP5NVUfEuhuf + + + + +create mFsSEF_3_iD2mT6nZG9QR + + Dictionary myuwTFtkH1L5Be2OVY9rt + ALL_DICTS mXAYJa6osZ6HNTIEEBnr0 + mVOlbMaOu1U0SC2oeKIzP + + + + + setDetectionMode mp3H4249LtCVDCYFqQqz4 + + + + + + DM_NORMAL mhyL_M5gnmQzwyHW45MdA mVOlbMaOu1U0SC2oeKIzP + + + + + + + muuG2jhk4iNsA9KNmj6oA + + + + + + +MarkerDetector_Impl mBBHVSlvDGP5NVUfEuhuf +MarkerDetector_Impl mhORIPgMIfN3Fn8aCQBuU + + mCujczJix6jMpJcynoBiA + + _1265885183454069381, mnqZGwZqTTi1dekKxujAE + + + + + + _1582275183843417612 mmCJ670wA_VHgip7JZ1dW + mDzQQrEx5Ki0C6uDHU2cy + + + + setDictionary mFlVjO0mLpwnCN5a1Quio + + + +_1265885183454069381,_1582275183843417612 mlqM0snvYcrWCw2_QjhQi + mlqoNTA3LQoUJF6i5YDFc + + + setDetectionMode mmmC9tOGiLK6UaJr0E5vz + DM_NORMAL mgkSwnYHQivQIpeAwgr20 + + + + + + mJTScPpWt8plE9Cz9fDU6 + + + + + + + mCvAz6nTbqhvwRULRgKe4 + + +MarkerDetector_Impl mpJt2kGThF7wb3VNzG38b + + +MarkerDetector_Impl mSa4WnWih0z4lSo9RYUGU + + + +std myuwTFtkH1L5Be2OVY9rt + + + + + + string _1265885183454069381, maISPbNJKXWB2QqsuuExM _1582275183843417612 mmCJ670wA_VHgip7JZ1dW + mN0TszoCQmyzxmobsgV2H + + + setDictionary mmmC9tOGiLK6UaJr0E5vz + _1265885183454069381,_1582275183843417612 mzf4ZxeZY8wF2XnrdYK61 + + + mhGXMe8LHJXydR9dMisHj + + + + + + + setDetectionMode mmmC9tOGiLK6UaJr0E5vz + + DM_NORMAL mzf4ZxeZY8wF2XnrdYK61 + mhGXMe8LHJXydR9dMisHj + + mnSkEvR4SbDwQxj23xB1M + + +MarkerDetector_Impl maKLz6mCz5anFyVle_MtD mbVacJ38Njfe_9kvqyl6v + + + + MarkerDetector_Impl maHkatHu0Jap4oTaT5q4_ + + + + + mnU2hwoI16_nZ7reLKJTr + + + + mbYMUxVFybbviIFqRhN2f + + + + + + + myqrAJLu9GRcs5sFEN1xM + + MarkerDetector_Impl mBBHVSlvDGP5NVUfEuhuf + + + + + + setParameters mmmC9tOGiLK6UaJr0E5vz + + + + const MarkerDetector mpJt2kGThF7wb3VNzG38b + + + Params &_10665546932953151066 mycwFs63h7Mi3ggRkMEVm + + mnU2hwoI16_nZ7reLKJTr + + + + + + _18062104616271777338 mCm219F3DHVwNe_CsrCeK + + + _10665546932953151066 mftnbgRvzOIVyL93HyyWt + + + + setDictionary mmmC9tOGiLK6UaJr0E5vz + + + + + + _18062104616271777338.dictionary,_18062104616271777338.error_correction_rate mXAYJa6osZ6HNTIEEBnr0 + mftnbgRvzOIVyL93HyyWt + + + + + mCvAz6nTbqhvwRULRgKe4 + + + + + + + + mfJA9NVd6FBgGhRSkkhhs + + MarkerDetector_Impl mEMN2sRTwHcTUl7SNSw0d + + + +setDetectionMode miAECMSxGwjxrcOKk0DII + + + + DetectionMode _16232574195068569506, maISPbNJKXWB2QqsuuExM + _11248109468844449006 mAnDeXfeHaujEzGBbrjil + + + + mDzQQrEx5Ki0C6uDHU2cy + + + + + + _18062104616271777338.setDetectionMode mSa4WnWih0z4lSo9RYUGU + + _16232574195068569506,_11248109468844449006 msubWq7nTVSPilWqmTzkx + + + + mxdAvfSsdzliezc0uyUMk + + + mDUyr1RAsHMG7u1BeTW3F + + + +DetectionMode MarkerDetector_Impl mUCEzhGWrU8OYqcHVPlVW + + + + + + getDetectionMode mhORIPgMIfN3Fn8aCQBuU + + + mgkSwnYHQivQIpeAwgr20 + + + mT_x8cqp5t43PgqNMR8gO + mlJqcdUT0sl1_64qaqDwc + + + + _18062104616271777338.detectMode mPdHdcAZ6XJhwf8wLtULI + + + + + muuG2jhk4iNsA9KNmj6oA + + + + + + + +std myuwTFtkH1L5Be2OVY9rt + + vector mlP1m6taP4mQVYA_j8Oxe + + + + +aruco mU808frSKQDZnEEU3Q3s9 + Marker m_j6ZkbEfLCgUqtaolYTp + + + + + MarkerDetector_Impl mUCEzhGWrU8OYqcHVPlVW detect mReDuVelSknxaDAoDEmwT + + + +const cv mBBHVSlvDGP5NVUfEuhuf + + + + Mat& _17276638435886805939 muiDYQbmwLxL3PGrwWGeP + + + mMRNM5hfPBWFjYCspldu3 + + + + + + + std mU808frSKQDZnEEU3Q3s9 + +vector mCALzjQ0bwpDnngl_oSsi + + + Marker mEc9zv3P8LW8haIvtztwe + + + _17726690318409070815 mJTScPpWt8plE9Cz9fDU6 + + + + + + detect mhORIPgMIfN3Fn8aCQBuU + + + + + + _17276638435886805939, _17726690318409070815 mgkSwnYHQivQIpeAwgr20 + + mhGXMe8LHJXydR9dMisHj + + + mTAavMivNX5WuUrRQXoEf + + + + _17726690318409070815 mJTScPpWt8plE9Cz9fDU6 + + + mhl3Z6oGBbP13ZxehUcg9 + + + +std mUCEzhGWrU8OYqcHVPlVW + vector mK5OxIt23gZzSiTA8trU8 + + + + + + aruco myuwTFtkH1L5Be2OVY9rt + + + Marker mRHNkLPwUSnx20pmLgrTq + + + MarkerDetector_Impl mEMN2sRTwHcTUl7SNSw0d + + detect mhORIPgMIfN3Fn8aCQBuU + const cv mfx1fLYDWN4YRZNnQEsJN + + + + Mat& _17276638435886805939, const CameraParameters& _6287083965332491608, + maOczvhF_v9OTsK70ZZut _3145974845315888936, + mcqTciDcDgSbPPY9iuwhB + + _7434016010995520486 mAnDeXfeHaujEzGBbrjil + + + + mJkMyi0NbVRDgE__LMR_m + + + + + + + std mYGfQUZmV9IjKAPVrLhZl + + vector mW1ds9XwNwevT5B2b3j8B + + + + + + Marker m_j6ZkbEfLCgUqtaolYTp + + + + _17726690318409070815 mVOlbMaOu1U0SC2oeKIzP + + + detect mhxtTU7dvZHXCTSg8B8rx + + + + + +_17276638435886805939, _17726690318409070815, _6287083965332491608, _3145974845315888936, _7434016010995520486 mzf4ZxeZY8wF2XnrdYK61 mJTScPpWt8plE9Cz9fDU6 + + mGbN63kjoGx6fvYq0oiYN + + _17726690318409070815 mPdHdcAZ6XJhwf8wLtULI + + mbYMUxVFybbviIFqRhN2f + + + + + mQk9KGg1kmiZQnIZzbOuE + + + + MarkerDetector_Impl maKLz6mCz5anFyVle_MtD + + detect miAECMSxGwjxrcOKk0DII + const cv mEMN2sRTwHcTUl7SNSw0d + + + + Mat& _17276638435886805939, std mUCEzhGWrU8OYqcHVPlVW + + vector mW1ds9XwNwevT5B2b3j8B + + Marker m_j6ZkbEfLCgUqtaolYTp + + + + & _17726690318409070815, CameraParameters _6287083965332491608, + mWokjWH0MHqyBOx4j0Oac + +_3145974845315888936, mpHTdkvfapV5_Igrm_XSs + + +_606330642723070475 muiDYQbmwLxL3PGrwWGeP + + + mfKhTg3wpiK_YhdQzWWcS + mUFzn4yJGA8c9qnEcb9dH + + + + mFlVjO0mLpwnCN5a1Quio + + +_6287083965332491608.CamSize mTna5ZWhTRHGhmpdDhP8Q + + _17276638435886805939.size mbHCSQc_uaLNP9Sf4Lz_n + + mgN2NPegMIWZaSlArqSpX + + _6287083965332491608.isValid mKpq3GwvJxRduE5RsGgGP + + + + + + mECamByxBqjGyTShbPlRQ + + + + + _3145974845315888936 mW1YUos9eL_9NmgJuSDH7 + + 0 mXAYJa6osZ6HNTIEEBnr0 + + + + + mfKhTg3wpiK_YhdQzWWcS + + CameraParameters _12703569624433759163 mRwjoMr_aqph4iL4nu8NS + + + + + + _6287083965332491608 mINcNsH05D0QZDej9wl4h + + + _12703569624433759163.resize miAECMSxGwjxrcOKk0DII _17276638435886805939.size mH1xQMRmYb0Y4RDp2hARz + + + + msubWq7nTVSPilWqmTzkx + + + mhGXMe8LHJXydR9dMisHj + + detect mhORIPgMIfN3Fn8aCQBuU + + _17276638435886805939, _17726690318409070815, _12703569624433759163.CameraMatrix, _12703569624433759163.Distorsion, _3145974845315888936, _606330642723070475 mlqM0snvYcrWCw2_QjhQi + + mlqoNTA3LQoUJF6i5YDFc + + + + + + + mICILgDpdCTDSJqQAn06L + + + else + mN0TszoCQmyzxmobsgV2H + + + + + + + detect mhORIPgMIfN3Fn8aCQBuU + + + _17276638435886805939, _17726690318409070815, _6287083965332491608.CameraMatrix, _6287083965332491608.Distorsion, _3145974845315888936,_606330642723070475 muiDYQbmwLxL3PGrwWGeP + + mlqoNTA3LQoUJF6i5YDFc + + + + mgjPImSFwUcUKl9XTKqqB + + + mgjPImSFwUcUKl9XTKqqB + + + + mP8l6554fUQhsCw2PetD2 + + + + + + MarkerDetector_Impl mpJt2kGThF7wb3VNzG38b + + _2048331705952164624 mwTQhkbVNQHd2Xw4EA4fj + + + + + + mN0TszoCQmyzxmobsgV2H + + + + mF8CPQI5IssWjwlV2CXVE + + + +_5268605236511778998 mdKhcOUXVqyCMdccisL_a + + + + + + _4383831888714590158 mwBOm3LXJ8FMsqTgQKZ6O + + + + + + getBestInputSize maHkatHu0Jap4oTaT5q4_ + + mriCvhMavpfheoLNc0eCD + + + + mEwOO8zzJcEkF96gfFa1e + + + + mSa4WnWih0z4lSo9RYUGU _5268605236511778998 mHgo4JTEAdFhAHz3buc5U + + + + -1 muiDYQbmwLxL3PGrwWGeP + mow1IjdflpN81ICD702rC + _5268605236511778998 mPdHdcAZ6XJhwf8wLtULI + + + + + mMGij61UZUIIYyztVz9vN + +_3257891858023991167 mKcKHr_bTagXAK_pf8btG + + _4383831888714590158 mqENAtmVRtspFcCyFxQkl + + + + getNSubdivisions mbHCSQc_uaLNP9Sf4Lz_n mPdHdcAZ6XJhwf8wLtULI + + mabeHDqoCFUg5Mty5oLni + + mhORIPgMIfN3Fn8aCQBuU + + + + +_3257891858023991167 mtPtbM6hNfOIkqlx661ci + + + + -1 mmCJ670wA_VHgip7JZ1dW + + _3257891858023991167 mKcKHr_bTagXAK_pf8btG + + + + +7 mxdAvfSsdzliezc0uyUMk + mow1IjdflpN81ICD702rC + + + _18062104616271777338.markerWarpPixSize*_3257891858023991167 mJTScPpWt8plE9Cz9fDU6 + + + + + + mJOnXqKm3GBylSdRjpXAA + + + + + + + mAQWugjGggd1dm4Esoytv + MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + + + + + + _11672520815028075718 mhxtTU7dvZHXCTSg8B8rx + + vector mlP1m6taP4mQVYA_j8Oxe + + +cv mpJt2kGThF7wb3VNzG38b + + Mat m_j6ZkbEfLCgUqtaolYTp + &_68274921722597584,const cv myuwTFtkH1L5Be2OVY9rt + + + + + + Mat &_3177068552073086628, mdbRZP7cWFYlUcaGRMsKc _9531480675436973396 mycwFs63h7Mi3ggRkMEVm + + + mjbtcSgN5ZQfkGDsoYG4l + + + + + moI11mwtxiOXpqDxK_aQL + + + _1691169752730655240 mCm219F3DHVwNe_CsrCeK + + + + + + 1 mriCvhMavpfheoLNc0eCD + + + + cv mU808frSKQDZnEEU3Q3s9 + + Size _10737131721194616638 mCm219F3DHVwNe_CsrCeK + + + + _3177068552073086628.size mzeHK1hG1SYQMISNMWMB8 mPdHdcAZ6XJhwf8wLtULI + + + while mtbP4KQJdh36UGELfV2zq + + _10737131721194616638.width m_j6ZkbEfLCgUqtaolYTp + + + + + + _9531480675436973396 mzf4ZxeZY8wF2XnrdYK61 + + mJkMyi0NbVRDgE__LMR_m + + + _10737131721194616638 mu_nOcTFwUo8r0uNE351R + + + + cv mU808frSKQDZnEEU3Q3s9 + + + Size mmmC9tOGiLK6UaJr0E5vz + + _10737131721194616638.width/_18062104616271777338.pyrfactor,_10737131721194616638.height/_18062104616271777338.pyrfactor mmCJ670wA_VHgip7JZ1dW + + mftnbgRvzOIVyL93HyyWt + _1691169752730655240 mnlCUtQ6kn1Qc7HkEzE0c + + + mriCvhMavpfheoLNc0eCD + mgjPImSFwUcUKl9XTKqqB + + + + + + + _68274921722597584.resize mFsSEF_3_iD2mT6nZG9QR _1691169752730655240 mgkSwnYHQivQIpeAwgr20 + + + mJTScPpWt8plE9Cz9fDU6 + + + + _14234691456098337398 mFyKKLtdivGGDlk8sYzsf + + + 0 mo8MRbS3DUX_ZOlgmUSna mdKhcOUXVqyCMdccisL_a + + + + + + _3177068552073086628 mINcNsH05D0QZDej9wl4h + + + + + + + _10737131721194616638 myJHqW7fkn_72nVEhKeZ6 + + + + _3177068552073086628.size mf_hJsy06Me1epT4PRx_l + + + + + + mftnbgRvzOIVyL93HyyWt + + + + + + mhXXYzAVu3lDYyh7TkRWq + mihBlyb7pwidO496a5_p1 + + _13303058356268144138 muQdV4OJL6V6gVxW6AdRy + + 1 mxdAvfSsdzliezc0uyUMk + _13303058356268144138 mlP1m6taP4mQVYA_j8Oxe + + + + _1691169752730655240 mINcNsH05D0QZDej9wl4h + + _13303058356268144138 mkGHGzUDDVqHIjIdYGe6S + + + + mycwFs63h7Mi3ggRkMEVm + mN0TszoCQmyzxmobsgV2H + + + + + + cv maKLz6mCz5anFyVle_MtD + + Size _15915597540354938205 mmmC9tOGiLK6UaJr0E5vz + + + _68274921722597584 mNDJrNgMXB1tBoFNaJO0d + _13303058356268144138-1 msdqcdg5NNrdQnc_PT1Ee + + .cols/_18062104616271777338.pyrfactor,_68274921722597584 mWkGo8xUdRIKgJ1DEUvvn + _13303058356268144138-1 mDd5IIsnjfLI1lcygRsW3 + + + +.rows/_18062104616271777338.pyrfactor mAnDeXfeHaujEzGBbrjil + + + + mJTScPpWt8plE9Cz9fDU6 + + cv mfx1fLYDWN4YRZNnQEsJN + resize mReDuVelSknxaDAoDEmwT + _68274921722597584 mY2nz8M_6jpSxQZL8EYgU + + + + + + _13303058356268144138-1 mIkhxhgSNMt_JUZR7ce1U + + + ,_68274921722597584 mZnfmoDANjVLDjZfzM5MR + _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee + + + + ,_15915597540354938205 mhyL_M5gnmQzwyHW45MdA + + mriCvhMavpfheoLNc0eCD + + + maCQ9r5fSln_CXgRXGFvO + + mCvAz6nTbqhvwRULRgKe4 + + + + + + myqrAJLu9GRcs5sFEN1xM + + + impl_assignClass_fast mhORIPgMIfN3Fn8aCQBuU const cv mBBHVSlvDGP5NVUfEuhuf + + Mat &_16232574195069562408, std mEMN2sRTwHcTUl7SNSw0d + + + vector mHkLXuUOlyX2vZI7w3FQj + + + cv myuwTFtkH1L5Be2OVY9rt + + KeyPoint mRHNkLPwUSnx20pmLgrTq + & _414219072103044861, mpMWr23OozoNFIk9M3JRl + + + _3176948347770171375, mCujczJix6jMpJcynoBiA + _11909274222260322758 mzf4ZxeZY8wF2XnrdYK61 + + + + + + + mDzQQrEx5Ki0C6uDHU2cy + + + mX_x9bVx2zqKO8c2FxqgZ + + + + + _16232574195069562408.type mzeHK1hG1SYQMISNMWMB8 + + mHgo4JTEAdFhAHz3buc5U + + CV_8UC1 mXAYJa6osZ6HNTIEEBnr0 + + + + + + throw std mBBHVSlvDGP5NVUfEuhuf runtime_error mSa4WnWih0z4lSo9RYUGU + + + + "\x5c\x78\x36\x31\x5c\x78\x37\x33\x5c\x78\x37\x33\x5c\x78\x36\x39\x5c\x78\x36\x37\x5c\x78\x36\x65\x5c\x78\x34\x33\x5c\x78\x36\x63\x5c\x78\x36\x31\x5c\x78\x37\x33\x5c\x78\x37\x33\x5c\x78\x35\x66\x5c\x78\x36\x36\x5c\x78\x36\x31\x5c\x78\x37\x33\x5c\x78\x37\x34\x5c\x78\x32\x30\x5c\x78\x34\x39\x5c\x78\x36\x65\x5c\x78\x37\x30\x5c\x78\x37\x35\x5c\x78\x37\x34\x5c\x78\x32\x30\x5c\x78\x36\x39\x5c\x78\x36\x64\x5c\x78\x36\x31\x5c\x78\x36\x37\x5c\x78\x36\x35\x5c\x78\x32\x30\x5c\x78\x36\x64\x5c\x78\x37\x35\x5c\x78\x37\x33\x5c\x78\x37\x34\x5c\x78\x32\x30\x5c\x78\x36\x32\x5c\x78\x36\x35\x5c\x78\x32\x30\x5c\x78\x33\x38\x5c\x78\x35\x35\x5c\x78\x34\x33\x5c\x78\x33\x31" mzf4ZxeZY8wF2XnrdYK61 + + mINcNsH05D0QZDej9wl4h + + mMGij61UZUIIYyztVz9vN + + + _8327405616267030056 muQdV4OJL6V6gVxW6AdRy +_11909274222260322758*2+1 mVOlbMaOu1U0SC2oeKIzP + + + cv mU808frSKQDZnEEU3Q3s9 Mat _7770143409063853332 mRwjoMr_aqph4iL4nu8NS cv mBBHVSlvDGP5NVUfEuhuf + + + + Mat myuwTFtkH1L5Be2OVY9rt + + zeros mReDuVelSknxaDAoDEmwT + + + _11909274222260322758*2+1,_11909274222260322758*2+1,CV_8UC1 mycwFs63h7Mi3ggRkMEVm + + + + + + mVOlbMaOu1U0SC2oeKIzP + + + + + + cv mBBHVSlvDGP5NVUfEuhuf +Mat _1198931547899984731 muQdV4OJL6V6gVxW6AdRy + cv maKLz6mCz5anFyVle_MtD + + Mat mhxtTU7dvZHXCTSg8B8rx + +_11909274222260322758*2+1,_11909274222260322758*2+1,CV_8UC1 mXAYJa6osZ6HNTIEEBnr0 + + + + mhGXMe8LHJXydR9dMisHj + + + + + + + + miGFoFUQX5urgUZ1Rewwt + + + + mF8CPQI5IssWjwlV2CXVE + + + + + + &_16232574195069566594:_414219072103044861 mycwFs63h7Mi3ggRkMEVm + + + mDzQQrEx5Ki0C6uDHU2cy + + + + + mCujczJix6jMpJcynoBiA + + + + _13303058356268144065 muQdV4OJL6V6gVxW6AdRy _16232574195069566594.pt.x+0.5f mftnbgRvzOIVyL93HyyWt + + + mSD7jHYN8mOif4_CBtIg6 + + + + +_13303058356268144023 muQdV4OJL6V6gVxW6AdRy + + + _16232574195069566594.pt.y+0.5f mPdHdcAZ6XJhwf8wLtULI + + + + + cv mfx1fLYDWN4YRZNnQEsJN + + + Rect _13303058356268144075 muQdV4OJL6V6gVxW6AdRy + + + cv mpJt2kGThF7wb3VNzG38b + + + + + + Rect mSa4WnWih0z4lSo9RYUGU + + _13303058356268144065-_11909274222260322758,_13303058356268144023-_11909274222260322758,_11909274222260322758*2+1,_11909274222260322758*2+1 mycwFs63h7Mi3ggRkMEVm + mxdAvfSsdzliezc0uyUMk + + + + mBuRRlPSkgfIqW4MkJEkn _13303058356268144075.x mW1ds9XwNwevT5B2b3j8B + + + + + + 0 mgM8ScCmoJ3qXwMzVOzZc + + _13303058356268144075.x+_13303058356268144075.width mtJAThUzPUAnb_DMXiQOL + + _16232574195069562408.cols mfNhxMALMjy2jMKPPP3pN + + + + _13303058356268144075.y mCALzjQ0bwpDnngl_oSsi + + + + +0 mgM8ScCmoJ3qXwMzVOzZc _13303058356268144075.y+_13303058356268144075.height mel3l7ZRXwnAEsy0Wfxj_ + + + + +_16232574195069562408.rows mycwFs63h7Mi3ggRkMEVm + continue mlqoNTA3LQoUJF6i5YDFc + + + + + mdbRZP7cWFYlUcaGRMsKc + + + _3176948340369703937 mu_nOcTFwUo8r0uNE351R + _13303058356268144075.x+_13303058356268144075.width mPdHdcAZ6XJhwf8wLtULI + + + + mihBlyb7pwidO496a5_p1 + _3176948340369704860 mKcKHr_bTagXAK_pf8btG + + + + + + _13303058356268144075.y+_13303058356268144075.height mftnbgRvzOIVyL93HyyWt + + + + + uchar _3176948348563158861 muQdV4OJL6V6gVxW6AdRy + + 255,_3257891898253592022 mu_nOcTFwUo8r0uNE351R + + + + 0 mftnbgRvzOIVyL93HyyWt + + + + + ma9rnYFEs_TUiw_WyBflg + + mSD7jHYN8mOif4_CBtIg6 + + _13303058356268144023 mCm219F3DHVwNe_CsrCeK + _13303058356268144075.y mdmuaUz9iCkCckSUhcEv1 + + _13303058356268144023 mCALzjQ0bwpDnngl_oSsi + + + + _3176948340369704860 mftnbgRvzOIVyL93HyyWt + + _13303058356268144023 mEZrtAN7pSZl5y4oEHd38 + + + + mXAYJa6osZ6HNTIEEBnr0 + + + + + + mnU2hwoI16_nZ7reLKJTr + + + + const uchar *_5268605234499577910 mif4ZCBkqdiqSYkR9AD0r + _16232574195069562408.ptr mCALzjQ0bwpDnngl_oSsi + + + uchar mE4_Vrik0lveh4HNJUk1B + mReDuVelSknxaDAoDEmwT + + + + _13303058356268144023 mgkSwnYHQivQIpeAwgr20 + + mJTScPpWt8plE9Cz9fDU6 + + + + + mVRbVdVjFvNmKzGv4WiNp + + + + + + mCujczJix6jMpJcynoBiA + + + + _13303058356268144065 mu_nOcTFwUo8r0uNE351R + + + + + _13303058356268144075.x mriCvhMavpfheoLNc0eCD + + _13303058356268144065 mW1ds9XwNwevT5B2b3j8B + + + _3176948340369703937 mdmuaUz9iCkCckSUhcEv1 + + _13303058356268144065 mUq8qfNXjDE9FPlMHvjf4 + + + mycwFs63h7Mi3ggRkMEVm + + + + + + mDzQQrEx5Ki0C6uDHU2cy + + + + + mXkfygpbRUCrOfJA4ktlP + + + + _3176948348563158861 mjxPa00ei9qkuuQmiGB3C + + _5268605234499577910 mFyKKLtdivGGDlk8sYzsf _13303058356268144065 mwTp2D1d4PfxNNOzzUfhS + + + + muiDYQbmwLxL3PGrwWGeP + + + + + + _3176948348563158861 mu_nOcTFwUo8r0uNE351R + + + + + + _5268605234499577910 mdF98bHO7yrxGJn0aQZVK + + _13303058356268144065 msdqcdg5NNrdQnc_PT1Ee + mriCvhMavpfheoLNc0eCD + + mSuHweZ8NLqp3TniIO9nc + _3257891898253592022 mCALzjQ0bwpDnngl_oSsi + + + + +_5268605234499577910 mZnfmoDANjVLDjZfzM5MR + + + + + + _13303058356268144065 mUB1yrSrKOwldqxmCatN2 + + msubWq7nTVSPilWqmTzkx + + + + _3257891898253592022 mCm219F3DHVwNe_CsrCeK _5268605234499577910 mFyKKLtdivGGDlk8sYzsf + + + _13303058356268144065 mIkhxhgSNMt_JUZR7ce1U mVOlbMaOu1U0SC2oeKIzP + + + mbYMUxVFybbviIFqRhN2f + + + + + + + muuG2jhk4iNsA9KNmj6oA + + + + mJvv2tbrel2xOYjvgipUL + + + + mmmC9tOGiLK6UaJr0E5vz + + mhxtTU7dvZHXCTSg8B8rx _3257891898253592022-_3176948348563158861 mhyL_M5gnmQzwyHW45MdA + + + + mlP1m6taP4mQVYA_j8Oxe + + + 25 mAnDeXfeHaujEzGBbrjil + + mjbtcSgN5ZQfkGDsoYG4l + + + _16232574195069566594.class_id myJHqW7fkn_72nVEhKeZ6 0 mJTScPpWt8plE9Cz9fDU6 + + continue mlqoNTA3LQoUJF6i5YDFc + + + muuG2jhk4iNsA9KNmj6oA + + + mPBSejyyYBZX7KoLjIvqq _16941263804935501574 mM3tRrWbRPqPOU3G4ShKT + + mhxtTU7dvZHXCTSg8B8rx + + + + _3257891898253592022+_3176948348563158861 mmCJ670wA_VHgip7JZ1dW + + + /2.0 mriCvhMavpfheoLNc0eCD + + + unsigned moI11mwtxiOXpqDxK_aQL + + + + _16232574195041799150 myJHqW7fkn_72nVEhKeZ6 + + 0 mVOlbMaOu1U0SC2oeKIzP + + + + ms9iveRK8Fk_QtPMDvDcP + + + + + mCujczJix6jMpJcynoBiA + + _13303058356268144023 mdKhcOUXVqyCMdccisL_a + + 0 mdmuaUz9iCkCckSUhcEv1 + _13303058356268144023 mW1ds9XwNwevT5B2b3j8B _8327405616267030056 mJTScPpWt8plE9Cz9fDU6 + + + _13303058356268144023 mkGHGzUDDVqHIjIdYGe6S + + mzf4ZxeZY8wF2XnrdYK61 + + + + mnU2hwoI16_nZ7reLKJTr + + + + const uchar *_5268605234499577910 mu_nOcTFwUo8r0uNE351R + + + + + + _16232574195069562408.ptr mYI2nkSxgJHf1pY1PttV1 + uchar mjxPa00ei9qkuuQmiGB3C + + mmmC9tOGiLK6UaJr0E5vz + + _13303058356268144075.y+_13303058356268144023 mAnDeXfeHaujEzGBbrjil + + +_13303058356268144075.x mlqoNTA3LQoUJF6i5YDFc + + uchar *_3861841962186570485 muQdV4OJL6V6gVxW6AdRy + + _1198931547899984731.ptr mbG1GEmOdh2dXkJZ42sXo + + + uchar mBpPKNB5wfuTOV223BA2r + + mFlVjO0mLpwnCN5a1Quio + + + + _13303058356268144023 mmCJ670wA_VHgip7JZ1dW + + + + + + mftnbgRvzOIVyL93HyyWt + + + + mhXXYzAVu3lDYyh7TkRWq + + + mdbRZP7cWFYlUcaGRMsKc + + _13303058356268144065 mM3tRrWbRPqPOU3G4ShKT + + + 0 mVOlbMaOu1U0SC2oeKIzP _13303058356268144065 mqEAvVDOCXqrrwrTRByrM _8327405616267030056 mVOlbMaOu1U0SC2oeKIzP + + + _13303058356268144065 mBh4lc09qKYGXyU7FeqOv + + + mmCJ670wA_VHgip7JZ1dW + mLdYY4X2b7VOjtTSnd7Hj + + + + + + + mXkfygpbRUCrOfJA4ktlP + + _5268605234499577910 mY2nz8M_6jpSxQZL8EYgU + + + + + + _13303058356268144065 mrpQVzv6u8gxvho1qUlil + + + + + + mYxohqgekcJ8HhaDZvWcX + + + +_16941263804935501574 mXAYJa6osZ6HNTIEEBnr0 + + + + mN0TszoCQmyzxmobsgV2H + + + + + _16232574195041799150 mt0bWs8kxCzTnBdtR9vKu + + mxdAvfSsdzliezc0uyUMk + + + + _3861841962186570485 mA4oXllup8K3T5dxkluRR + + _13303058356268144065 mbViqhyIcr6lGWibuo3Im + + + + + + mCm219F3DHVwNe_CsrCeK + + + + + 255 mftnbgRvzOIVyL93HyyWt + + + mnSkEvR4SbDwQxj23xB1M + + + mFK5JCwqLjSVNjbuFv1Xz + _3861841962186570485 mY2nz8M_6jpSxQZL8EYgU + + + + + + _13303058356268144065 msdqcdg5NNrdQnc_PT1Ee + + + mif4ZCBkqdiqSYkR9AD0r + 0 mriCvhMavpfheoLNc0eCD + + mnSkEvR4SbDwQxj23xB1M + + + + + mCvAz6nTbqhvwRULRgKe4 + + + + ma9rnYFEs_TUiw_WyBflg + + moI11mwtxiOXpqDxK_aQL + + + + _13303058356268144023 muQdV4OJL6V6gVxW6AdRy + + + 0 mdmuaUz9iCkCckSUhcEv1 _13303058356268144023 mqEAvVDOCXqrrwrTRByrM + _1198931547899984731.rows mPdHdcAZ6XJhwf8wLtULI + + + + + _13303058356268144023 mi940TUip6nLdi0tWD33F mgkSwnYHQivQIpeAwgr20 mnU2hwoI16_nZ7reLKJTr + + + uchar *_10102288860402729761 mu_nOcTFwUo8r0uNE351R + + + _7770143409063853332.ptr mHkLXuUOlyX2vZI7w3FQj + uchar mBpPKNB5wfuTOV223BA2r + mhxtTU7dvZHXCTSg8B8rx + + _13303058356268144023 muiDYQbmwLxL3PGrwWGeP + + + + + mPdHdcAZ6XJhwf8wLtULI + + + + + + moPdTa5HpJKbS1U6TqDjY mMGij61UZUIIYyztVz9vN + + + + + +_13303058356268144065 mKcKHr_bTagXAK_pf8btG + + + + + +0 mINcNsH05D0QZDej9wl4h + + _13303058356268144065 mbG1GEmOdh2dXkJZ42sXo + + + + _1198931547899984731.cols mPdHdcAZ6XJhwf8wLtULI + + + + + + _13303058356268144065 mEZrtAN7pSZl5y4oEHd38 + + + + + + mycwFs63h7Mi3ggRkMEVm + _10102288860402729761 mGYpOkNIG_qSvYXBOU9Vf +_13303058356268144065 mwTp2D1d4PfxNNOzzUfhS + + + + + + mM3tRrWbRPqPOU3G4ShKT + 0 mdmuaUz9iCkCckSUhcEv1 + + + + mnSkEvR4SbDwQxj23xB1M + + + + uchar _2527482952837276942 myJHqW7fkn_72nVEhKeZ6 + + 1 mPdHdcAZ6XJhwf8wLtULI + std mdssZV6TB06aiisDwN1cX + + map mqEAvVDOCXqrrwrTRByrM + + + + + uchar, uchar mEc9zv3P8LW8haIvtztwe + _17627748882047670830 mhGXMe8LHJXydR9dMisHj + + + mhXXYzAVu3lDYyh7TkRWq mG7mr0Iq8BCEeADSwrCoW + + + _13303058356268144023 mdKhcOUXVqyCMdccisL_a + + + + + 0 mINcNsH05D0QZDej9wl4h + + + + + + _13303058356268144023 mbG1GEmOdh2dXkJZ42sXo + + _1198931547899984731.rows mVOlbMaOu1U0SC2oeKIzP + + + + _13303058356268144023 mBh4lc09qKYGXyU7FeqOv + + + mzf4ZxeZY8wF2XnrdYK61 + + mjbtcSgN5ZQfkGDsoYG4l + + uchar *_3861841962186570485 mCm219F3DHVwNe_CsrCeK + + _1198931547899984731.ptr mK5OxIt23gZzSiTA8trU8 + uchar mW1YUos9eL_9NmgJuSDH7 + + + + + + mhxtTU7dvZHXCTSg8B8rx +_13303058356268144023 muiDYQbmwLxL3PGrwWGeP + + + + + + mINcNsH05D0QZDej9wl4h + + + uchar *_10102288860402729761 mKcKHr_bTagXAK_pf8btG + + _7770143409063853332.ptr mca1GaR7Rv9qOZsisqKBB + uchar mYxohqgekcJ8HhaDZvWcX + + + + + + mhxtTU7dvZHXCTSg8B8rx + + + + + +_13303058356268144023 mXAYJa6osZ6HNTIEEBnr0 + + mlqoNTA3LQoUJF6i5YDFc + + mVRbVdVjFvNmKzGv4WiNp + mihBlyb7pwidO496a5_p1 + + _13303058356268144065 mif4ZCBkqdiqSYkR9AD0r + + + 0 mJTScPpWt8plE9Cz9fDU6 + + _13303058356268144065 mHkLXuUOlyX2vZI7w3FQj + _1198931547899984731.cols mxdAvfSsdzliezc0uyUMk + + + + + _13303058356268144065 mUq8qfNXjDE9FPlMHvjf4 + + mXAYJa6osZ6HNTIEEBnr0 + + + + mN0TszoCQmyzxmobsgV2H + + + + + uchar _5268611907152127627 mM3tRrWbRPqPOU3G4ShKT + + + _3861841962186570485 mA4oXllup8K3T5dxkluRR + + _13303058356268144065 mJtGCV8zXQjnVDVBVdvFZ + + + + mxdAvfSsdzliezc0uyUMk + + + uchar _14281707985483758147 mRwjoMr_aqph4iL4nu8NS + + 0 mVOlbMaOu1U0SC2oeKIzP + + + + uchar _12923587428288459517 mu_nOcTFwUo8r0uNE351R + + + + + + 0 mriCvhMavpfheoLNc0eCD + + + + + mXkfygpbRUCrOfJA4ktlP + + _13303058356268144065-1 mYxohqgekcJ8HhaDZvWcX + + + + -1 mhyL_M5gnmQzwyHW45MdA + + + + + + + mMRNM5hfPBWFjYCspldu3 + mVHGLK1C5RNdKdXzDgMZU + + + + _5268611907152127627 mRuVXNtG32xpaNLi1hDLk + + + + _3861841962186570485 mdF98bHO7yrxGJn0aQZVK + _13303058356268144065-1 mwTp2D1d4PfxNNOzzUfhS + + + + muiDYQbmwLxL3PGrwWGeP + + + + + + _14281707985483758147 mu_nOcTFwUo8r0uNE351R _10102288860402729761 mILaQGKCAmcKrYQNhgWUq + + + + + + _13303058356268144065-1 mUB1yrSrKOwldqxmCatN2 + + + + + mPdHdcAZ6XJhwf8wLtULI + + + + + + + maCQ9r5fSln_CXgRXGFvO + + + + + + mb_mniVMqcXJMFkJcXnTV + + + + _13303058356268144023-1 mW1YUos9eL_9NmgJuSDH7 + + + + + -1 mhyL_M5gnmQzwyHW45MdA + + + + + mnU2hwoI16_nZ7reLKJTr + + + + + mb_mniVMqcXJMFkJcXnTV +_5268611907152127627 mi0dc2wlXgNoHf9VPli9f + + + + _1198931547899984731.ptr mK5OxIt23gZzSiTA8trU8 + uchar mE4_Vrik0lveh4HNJUk1B + + mSa4WnWih0z4lSo9RYUGU + + + _13303058356268144023-1 muiDYQbmwLxL3PGrwWGeP + + + + + mNDJrNgMXB1tBoFNaJO0d + + + + _13303058356268144065 msdqcdg5NNrdQnc_PT1Ee + msubWq7nTVSPilWqmTzkx + + + _12923587428288459517 ma6VjqdfajK4BX9gkoGiD + _7770143409063853332.at mW1ds9XwNwevT5B2b3j8B +uchar mjxPa00ei9qkuuQmiGB3C + + + mhxtTU7dvZHXCTSg8B8rx + + + _13303058356268144023-1, _13303058356268144065 mhyL_M5gnmQzwyHW45MdA + + mlqoNTA3LQoUJF6i5YDFc + + + mgjPImSFwUcUKl9XTKqqB + + + mSuHweZ8NLqp3TniIO9nc + + _14281707985483758147 mnZ6t3BhMZ_1d7zzE72ah + 0 mgN2NPegMIWZaSlArqSpX + _12923587428288459517 mi0dc2wlXgNoHf9VPli9f + + + 0 mycwFs63h7Mi3ggRkMEVm + + _10102288860402729761 mA4oXllup8K3T5dxkluRR _13303058356268144065 mEFd2D2UDF9SIoPfQtUv6 + + muQdV4OJL6V6gVxW6AdRy + + + + _2527482952837276942 mt0bWs8kxCzTnBdtR9vKu + mftnbgRvzOIVyL93HyyWt + + + mHcxzZHoWX11H4xEjR59T + + mwxm9pz2KjGAhBIIfFMf4 + + _14281707985483758147 mWUoD50tT9HFGBNQCsjUC + 0 mKdH1o6rFuMJ1Fl0PA_sn + + + + _12923587428288459517 mu3VfwjYyEXmsa3FxHdyz + + 0 mhyL_M5gnmQzwyHW45MdA + + + mMRNM5hfPBWFjYCspldu3 + mXkfygpbRUCrOfJA4ktlP + + + + _14281707985483758147 mCALzjQ0bwpDnngl_oSsi + + + _12923587428288459517 mzf4ZxeZY8wF2XnrdYK61 + + + + mypSy3lS4LRIjRYTxVxzg + + + + + _10102288860402729761 mFyKKLtdivGGDlk8sYzsf + _13303058356268144065 mIkhxhgSNMt_JUZR7ce1U + myJHqW7fkn_72nVEhKeZ6 + + _14281707985483758147 mriCvhMavpfheoLNc0eCD + + _17627748882047670830 mY2nz8M_6jpSxQZL8EYgU _12923587428288459517 mbViqhyIcr6lGWibuo3Im + + + mif4ZCBkqdiqSYkR9AD0r _14281707985483758147 mxdAvfSsdzliezc0uyUMk + + mICILgDpdCTDSJqQAn06L + + + + + mHcxzZHoWX11H4xEjR59T + + mXyxJEKR2vQDAiXVkkZ96 +_14281707985483758147 m_j6ZkbEfLCgUqtaolYTp + _12923587428288459517 muiDYQbmwLxL3PGrwWGeP + + mJkMyi0NbVRDgE__LMR_m + _10102288860402729761 mFyKKLtdivGGDlk8sYzsf +_13303058356268144065 mEFd2D2UDF9SIoPfQtUv6 mCm219F3DHVwNe_CsrCeK + + + _12923587428288459517 mINcNsH05D0QZDej9wl4h + + + + + + _17627748882047670830 mY2nz8M_6jpSxQZL8EYgU _14281707985483758147 mbViqhyIcr6lGWibuo3Im + + + ma6VjqdfajK4BX9gkoGiD + + + + _12923587428288459517 mJTScPpWt8plE9Cz9fDU6 + + + + + muuG2jhk4iNsA9KNmj6oA + + + + + + + else + mLdYY4X2b7VOjtTSnd7Hj + + + + _10102288860402729761 mZnfmoDANjVLDjZfzM5MR + + _13303058356268144065 mJtGCV8zXQjnVDVBVdvFZ + + mdKhcOUXVqyCMdccisL_a + + + + _12923587428288459517 mriCvhMavpfheoLNc0eCD + mnSkEvR4SbDwQxj23xB1M + + maCQ9r5fSln_CXgRXGFvO + + else + mDzQQrEx5Ki0C6uDHU2cy + + + mikiSyOnVry6pvQ1Ds28H + _14281707985483758147 mHgo4JTEAdFhAHz3buc5U + 0 mlqM0snvYcrWCw2_QjhQi + + + _10102288860402729761 mdF98bHO7yrxGJn0aQZVK + + _13303058356268144065 mo8MRbS3DUX_ZOlgmUSna + + + mCm219F3DHVwNe_CsrCeK + + + _14281707985483758147 mriCvhMavpfheoLNc0eCD + + + + + muKP5B7qysoQRrYrwu_aG + + + + + + _10102288860402729761 mTjppsgNpY1Pjyv5Z_zMr + + +_13303058356268144065 mrpQVzv6u8gxvho1qUlil + + + + mKcKHr_bTagXAK_pf8btG + _12923587428288459517 mJTScPpWt8plE9Cz9fDU6 + + + + + + muuG2jhk4iNsA9KNmj6oA + + + + + mICILgDpdCTDSJqQAn06L + + + + + + + mhl3Z6oGBbP13ZxehUcg9 + + mdEzmAkZNQkKD1HrLnSSo + + + + + + _16232574195041797758 mRwjoMr_aqph4iL4nu8NS + + _2527482952837276942-1 - _17627748882047670830.size mwTQhkbVNQHd2Xw4EA4fj + + + + mxdAvfSsdzliezc0uyUMk + + + + mikiSyOnVry6pvQ1Ds28H + + + + _16232574195041797758 mgAgf2KiVOzOHJDU4qKPI + +2 mXAYJa6osZ6HNTIEEBnr0 + + mT_x8cqp5t43PgqNMR8gO + + + + mXkfygpbRUCrOfJA4ktlP + + + _16232574195041799150 mel3l7ZRXwnAEsy0Wfxj_ + _1198931547899984731.total mKpq3GwvJxRduE5RsGgGP + -_16232574195041799150 msubWq7nTVSPilWqmTzkx + + _16232574195069566594.class_id mKcKHr_bTagXAK_pf8btG + + 0 mriCvhMavpfheoLNc0eCD + + + + + mE_Ow4Xh61sHZuYT9u_vp + + + + _16232574195069566594.class_id muQdV4OJL6V6gVxW6AdRy 1 mlqoNTA3LQoUJF6i5YDFc + + + mCvAz6nTbqhvwRULRgKe4 + + + + + mFK5JCwqLjSVNjbuFv1Xz + + + + + mwQUfI7G4pBH6IJQiBjmU + mFlVjO0mLpwnCN5a1Quio + + + + + +_16232574195041797758 mYxohqgekcJ8HhaDZvWcX + + 2 mgkSwnYHQivQIpeAwgr20 + + mN0TszoCQmyzxmobsgV2H + + + + + _16232574195069566594.class_id mKcKHr_bTagXAK_pf8btG + + 2 mdmuaUz9iCkCckSUhcEv1 + + + + + mnSkEvR4SbDwQxj23xB1M + + + + muuG2jhk4iNsA9KNmj6oA + + + + mbYMUxVFybbviIFqRhN2f + + + + + + + + + + + + + + + + + + +vector mYfYoOWdsOLTDCIBT7npX + + MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + + MarkerCandidate mBpPKNB5wfuTOV223BA2r + MarkerDetector_Impl mUCEzhGWrU8OYqcHVPlVW +_11288135742209909849 mFsSEF_3_iD2mT6nZG9QR + + + + const cv mUCEzhGWrU8OYqcHVPlVW + Mat & _17276638435886805939, moI11mwtxiOXpqDxK_aQL + + + + _15830902196015336515, mG7mr0Iq8BCEeADSwrCoW + + _15830902196015336516, mpHTdkvfapV5_Igrm_XSs + + + + + _11520114173644902406,cv mUCEzhGWrU8OYqcHVPlVW + + + Mat &_451795507898897488 mzf4ZxeZY8wF2XnrdYK61 + mJkMyi0NbVRDgE__LMR_m + + + + + mJvv2tbrel2xOYjvgipUL + + + mSa4WnWih0z4lSo9RYUGU + + + + _15830902196015336515 mYI2nkSxgJHf1pY1PttV1 + + + + + + 3 mAnDeXfeHaujEzGBbrjil _15830902196015336515 mCm219F3DHVwNe_CsrCeK 3 mftnbgRvzOIVyL93HyyWt + + mv1ijGQAKacWqWAusY8nc + mRzhpvoeHZK7yCqqzYDDp + mSa4WnWih0z4lSo9RYUGU + + + + miAECMSxGwjxrcOKk0DII + + + + + + mmmC9tOGiLK6UaJr0E5vz + + mdEzmAkZNQkKD1HrLnSSo mAnDeXfeHaujEzGBbrjil + + + + + + _15830902196015336515 mAnDeXfeHaujEzGBbrjil + + % 2 muOzaq9SXefX6wOasanyX + + 1 mmCJ670wA_VHgip7JZ1dW + + _15830902196015336515 mdKhcOUXVqyCMdccisL_a + + + mp3H4249LtCVDCYFqQqz4 + mdbRZP7cWFYlUcaGRMsKc + + + + +mXAYJa6osZ6HNTIEEBnr0 + + + + + + mmmC9tOGiLK6UaJr0E5vz +_15830902196015336515 + 1 muiDYQbmwLxL3PGrwWGeP + mJTScPpWt8plE9Cz9fDU6 + + + + + + mG7mr0Iq8BCEeADSwrCoW + + _15680653421411319497 mif4ZCBkqdiqSYkR9AD0r + + + +-1 mJTScPpWt8plE9Cz9fDU6 + + + + cv mdssZV6TB06aiisDwN1cX + + + Mat _17629472122771957618 mINcNsH05D0QZDej9wl4h + + + + + + _17629472122771957618 mu_nOcTFwUo8r0uNE351R + + + _451795507898897488 mJTScPpWt8plE9Cz9fDU6 + + + mvw_MKiY3S1FcVNfJQCRT + + + + mhORIPgMIfN3Fn8aCQBuU + + _18062104616271777338.thresMethod mRuVXNtG32xpaNLi1hDLk + + + + MarkerDetector mpJt2kGThF7wb3VNzG38b + + + THRES_AUTO_FIXED mycwFs63h7Mi3ggRkMEVm + + + + mLdYY4X2b7VOjtTSnd7Hj + + cv mfx1fLYDWN4YRZNnQEsJN + + +threshold mSa4WnWih0z4lSo9RYUGU + + + + _17276638435886805939, _17629472122771957618, static_cast mYI2nkSxgJHf1pY1PttV1 + + + moI11mwtxiOXpqDxK_aQL + mtJAThUzPUAnb_DMXiQOL + + mReDuVelSknxaDAoDEmwT + _15830902196015336516 mmCJ670wA_VHgip7JZ1dW + + ,255,THRESH_BINARY_INV mzf4ZxeZY8wF2XnrdYK61 + + + + + mdmuaUz9iCkCckSUhcEv1 + + + + + + + mXkfygpbRUCrOfJA4ktlP + + + + + _11520114173644902406 mgkSwnYHQivQIpeAwgr20 + + mnU2hwoI16_nZ7reLKJTr + + + cv mYGfQUZmV9IjKAPVrLhZl + + + + + + Mat _3257871146051445030 mriCvhMavpfheoLNc0eCD + + + _15680653421411319497 mCm219F3DHVwNe_CsrCeK + + mdbRZP7cWFYlUcaGRMsKc + mSa4WnWih0z4lSo9RYUGU + + std mfx1fLYDWN4YRZNnQEsJN + + max mp3H4249LtCVDCYFqQqz4 3.0, 3./1920. * mlkEZnzYCXAgDnYDi5up3 + + mhORIPgMIfN3Fn8aCQBuU + _17629472122771957618.cols mycwFs63h7Mi3ggRkMEVm + + + + + + msubWq7nTVSPilWqmTzkx + mmCJ670wA_VHgip7JZ1dW + + + + + + mVOlbMaOu1U0SC2oeKIzP + + + + + mwQUfI7G4pBH6IJQiBjmU mtbP4KQJdh36UGELfV2zq + _15680653421411319497%2 mgAgf2KiVOzOHJDU4qKPI + + + 0 mgkSwnYHQivQIpeAwgr20 + + _15680653421411319497 mEZrtAN7pSZl5y4oEHd38 + + + + + + mVOlbMaOu1U0SC2oeKIzP + cv mfx1fLYDWN4YRZNnQEsJN + + + + erode mhORIPgMIfN3Fn8aCQBuU + + + + + + _17629472122771957618,_3257871146051445030, getStructuringElement mFsSEF_3_iD2mT6nZG9QR MORPH_CROSS,cv mpJt2kGThF7wb3VNzG38b + + + Size mFlVjO0mLpwnCN5a1Quio + _15680653421411319497, _15680653421411319497 mzf4ZxeZY8wF2XnrdYK61 + + + + ,cv mU808frSKQDZnEEU3Q3s9 + + Point mp3H4249LtCVDCYFqQqz4 + _15680653421411319497/2,_15680653421411319497/2 mXAYJa6osZ6HNTIEEBnr0 + + + + + + mzf4ZxeZY8wF2XnrdYK61 + + + + + mAnDeXfeHaujEzGBbrjil + mriCvhMavpfheoLNc0eCD + + + + + + + cv maKLz6mCz5anFyVle_MtD bitwise_xor mFsSEF_3_iD2mT6nZG9QR + _3257871146051445030,_17629472122771957618,_17629472122771957618 mzf4ZxeZY8wF2XnrdYK61 + mINcNsH05D0QZDej9wl4h + + mICILgDpdCTDSJqQAn06L + + maCQ9r5fSln_CXgRXGFvO + + + mE_Ow4Xh61sHZuYT9u_vp + + + + mDzQQrEx5Ki0C6uDHU2cy + + + + + + + cv mBBHVSlvDGP5NVUfEuhuf + adaptiveThreshold mp3H4249LtCVDCYFqQqz4 + + _17276638435886805939, _17629472122771957618, 255., ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY_INV, static_cast mca1GaR7Rv9qOZsisqKBB + + mihBlyb7pwidO496a5_p1 + + + + + mW1YUos9eL_9NmgJuSDH7 + + + mtbP4KQJdh36UGELfV2zq + _15830902196015336515 mlqM0snvYcrWCw2_QjhQi + , static_cast mK5OxIt23gZzSiTA8trU8 + + + + + meWm4MhzbcJwavtoh469w + + + + mBpPKNB5wfuTOV223BA2r + + + + + + mhxtTU7dvZHXCTSg8B8rx + +_15830902196015336516 mmCJ670wA_VHgip7JZ1dW + + mzf4ZxeZY8wF2XnrdYK61 + + mhGXMe8LHJXydR9dMisHj + + + + + _15680653421411319497 ma6VjqdfajK4BX9gkoGiD + + + _15830902196015336515 mPdHdcAZ6XJhwf8wLtULI + + + + mnSkEvR4SbDwQxj23xB1M + + + + + + + + + vector mW1ds9XwNwevT5B2b3j8B + + + + MarkerCandidate mE4_Vrik0lveh4HNJUk1B + + + + _6528263073538749848 mVOlbMaOu1U0SC2oeKIzP + + + + + + mdbRZP7cWFYlUcaGRMsKc + + _3622495794621911996 mCm219F3DHVwNe_CsrCeK + + + + mihBlyb7pwidO496a5_p1 miAECMSxGwjxrcOKk0DII 3.5*float mtbP4KQJdh36UGELfV2zq +_18062104616271777338.lowResMarkerSize mmCJ670wA_VHgip7JZ1dW + + msubWq7nTVSPilWqmTzkx + + + mftnbgRvzOIVyL93HyyWt + + + + std maKLz6mCz5anFyVle_MtD + + vector mqEAvVDOCXqrrwrTRByrM + + + + cv mYGfQUZmV9IjKAPVrLhZl + + Vec4i mW1YUos9eL_9NmgJuSDH7 + _10376581494285192551 mVOlbMaOu1U0SC2oeKIzP + + + + + + + std mEMN2sRTwHcTUl7SNSw0d + + + + vector mW1ds9XwNwevT5B2b3j8B + + + + std mpJt2kGThF7wb3VNzG38b + + + + + + vector mW1ds9XwNwevT5B2b3j8B + cv mU808frSKQDZnEEU3Q3s9 + + + + + + Point mIqkiLoOdpjYrPavNSkO3 + _10998538416191004035 mriCvhMavpfheoLNc0eCD + + + + cv mBBHVSlvDGP5NVUfEuhuf + + + + findContours mtbP4KQJdh36UGELfV2zq + _451795507898897488, _10998538416191004035, cv mpJt2kGThF7wb3VNzG38b + noArray maHkatHu0Jap4oTaT5q4_ + + + , cv maKLz6mCz5anFyVle_MtD + RETR_LIST, cv mEMN2sRTwHcTUl7SNSw0d CHAIN_APPROX_NONE mgkSwnYHQivQIpeAwgr20 + + + mlqoNTA3LQoUJF6i5YDFc + + + vector mW1ds9XwNwevT5B2b3j8B + Point mel3l7ZRXwnAEsy0Wfxj_ + + + + _18125075577596139249 mINcNsH05D0QZDej9wl4h + + +#ifdef _aruco_debug_detectrectangles + cv mfx1fLYDWN4YRZNnQEsJN + + Mat simage mJTScPpWt8plE9Cz9fDU6 + + + cv myuwTFtkH1L5Be2OVY9rt + + + + + +cvtColor mhxtTU7dvZHXCTSg8B8rx + + + + input,simage,CV_GRAY2BGR msubWq7nTVSPilWqmTzkx + + + + + + mVOlbMaOu1U0SC2oeKIzP + + + + + +#endif + + + mxQewHEnT8PTNQcVKCqL9 + + mhxtTU7dvZHXCTSg8B8rx + unsigned mP8l6554fUQhsCw2PetD2 + + _13303058356268144138 mRwjoMr_aqph4iL4nu8NS + + + + + + 0 mlqoNTA3LQoUJF6i5YDFc + + + _13303058356268144138 mYfYoOWdsOLTDCIBT7npX + + + + _10998538416191004035.size mbHCSQc_uaLNP9Sf4Lz_n + + mhGXMe8LHJXydR9dMisHj + + + + + + _13303058356268144138 mcstdE8Wwpam6tUMM45Sa + + + + + + mlqM0snvYcrWCw2_QjhQi + + + mypSy3lS4LRIjRYTxVxzg + + + + +#ifdef _aruco_debug_detectrectangles + drawContour mtbP4KQJdh36UGELfV2zq + + + + simage, contours mdF98bHO7yrxGJn0aQZVK + + i mEFd2D2UDF9SIoPfQtUv6 + , Scalar miAECMSxGwjxrcOKk0DII + + 125, 125, 255 msubWq7nTVSPilWqmTzkx + + muiDYQbmwLxL3PGrwWGeP + mftnbgRvzOIVyL93HyyWt + +#endif + + mUFzn4yJGA8c9qnEcb9dH + + + + mFlVjO0mLpwnCN5a1Quio + + _3622495794621911996 mK5OxIt23gZzSiTA8trU8 + + meWm4MhzbcJwavtoh469w + + + + + + mSa4WnWih0z4lSo9RYUGU + _10998538416191004035 mY2nz8M_6jpSxQZL8EYgU + + _13303058356268144138 mrpQVzv6u8gxvho1qUlil + + + + + +.size mwTQhkbVNQHd2Xw4EA4fj + + mhyL_M5gnmQzwyHW45MdA + + + + mycwFs63h7Mi3ggRkMEVm + + + + + mT_x8cqp5t43PgqNMR8gO + + + + + + + cv mEMN2sRTwHcTUl7SNSw0d + approxPolyDP mFlVjO0mLpwnCN5a1Quio + + _10998538416191004035 mTjppsgNpY1Pjyv5Z_zMr + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + + , _18125075577596139249, mSBH4REv5nn8iXIXWLqFa + + + + + +mhxtTU7dvZHXCTSg8B8rx + + + + _10998538416191004035 mNDJrNgMXB1tBoFNaJO0d + + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U .size maHkatHu0Jap4oTaT5q4_ + + + + msubWq7nTVSPilWqmTzkx * 0.05, mj7rzLUFNjZZ8TQ9LzphN + + + + +mlqM0snvYcrWCw2_QjhQi + + + + mVOlbMaOu1U0SC2oeKIzP + + + + mabeHDqoCFUg5Mty5oLni + + mSa4WnWih0z4lSo9RYUGU + _18125075577596139249.size mdWkXjuaPd4Se0r0SdY1e + + + + mYsjCP2nXqW2Jls3JAUkc + 4 mKdH1o6rFuMJ1Fl0PA_sn + + cv mUCEzhGWrU8OYqcHVPlVW + + isContourConvex mtbP4KQJdh36UGELfV2zq + + + + + + _18125075577596139249 mhyL_M5gnmQzwyHW45MdA + + + + mmCJ670wA_VHgip7JZ1dW + mN0TszoCQmyzxmobsgV2H + + +#ifdef _aruco_debug_detectrectangles + drawApproxCurve mSa4WnWih0z4lSo9RYUGU + + simage, approxCurve, Scalar mhxtTU7dvZHXCTSg8B8rx + + + + 255, 0, 255 mlqM0snvYcrWCw2_QjhQi + ,1 mXAYJa6osZ6HNTIEEBnr0 + mVOlbMaOu1U0SC2oeKIzP + +#endif + + mglDNKH5ah89GptW6H4Cu + + +_9594576219500337594 mRwjoMr_aqph4iL4nu8NS std mfx1fLYDWN4YRZNnQEsJN + + + + + + numeric_limits mlP1m6taP4mQVYA_j8Oxe + mnqZGwZqTTi1dekKxujAE + + + + + + mjxPa00ei9qkuuQmiGB3C + + mYGfQUZmV9IjKAPVrLhZl max mdWkXjuaPd4Se0r0SdY1e + + + + + + mhGXMe8LHJXydR9dMisHj + + + mxQewHEnT8PTNQcVKCqL9 + + + + mp3H4249LtCVDCYFqQqz4 + mdbRZP7cWFYlUcaGRMsKc +_13303058356268144139 mif4ZCBkqdiqSYkR9AD0r + 0 mPdHdcAZ6XJhwf8wLtULI _13303058356268144139 mYfYoOWdsOLTDCIBT7npX + + + 4 mJTScPpWt8plE9Cz9fDU6 _13303058356268144139 mBh4lc09qKYGXyU7FeqOv + + mycwFs63h7Mi3ggRkMEVm + + + + mnU2hwoI16_nZ7reLKJTr + + + + mglDNKH5ah89GptW6H4Cu + + _13303058356268144198 mif4ZCBkqdiqSYkR9AD0r + + cv mYGfQUZmV9IjKAPVrLhZl + + + + + + norm mFsSEF_3_iD2mT6nZG9QR + + + + + + _18125075577596139249 mZnfmoDANjVLDjZfzM5MR + + + _13303058356268144139 mrpQVzv6u8gxvho1qUlil + + -_18125075577596139249 mNDJrNgMXB1tBoFNaJO0d + + + + + + mReDuVelSknxaDAoDEmwT + + + + + + _13303058356268144139 + 1 mzf4ZxeZY8wF2XnrdYK61 + + + % 4 mrpQVzv6u8gxvho1qUlil + + muiDYQbmwLxL3PGrwWGeP + + mVOlbMaOu1U0SC2oeKIzP + + + + mJvv2tbrel2xOYjvgipUL + + mhORIPgMIfN3Fn8aCQBuU + + + + + + _13303058356268144198 mW1ds9XwNwevT5B2b3j8B + + _9594576219500337594 mAnDeXfeHaujEzGBbrjil + + + _9594576219500337594 mif4ZCBkqdiqSYkR9AD0r + + + _13303058356268144198 mriCvhMavpfheoLNc0eCD + + + mbYMUxVFybbviIFqRhN2f + + + + _6528263073538749848.push_back mhxtTU7dvZHXCTSg8B8rx + MarkerCandidate mcznTYeCGOAygtXXAPYS_ + + + + + mlqM0snvYcrWCw2_QjhQi + + + + + + mVOlbMaOu1U0SC2oeKIzP + + maB_pNl4zuODt3oqXg9EB + + mReDuVelSknxaDAoDEmwT + + mG7mr0Iq8BCEeADSwrCoW + _13303058356268144139 ma6VjqdfajK4BX9gkoGiD + + 0 mlqoNTA3LQoUJF6i5YDFc + _13303058356268144139 mca1GaR7Rv9qOZsisqKBB + + + 4 mINcNsH05D0QZDej9wl4h + _13303058356268144139 mBh4lc09qKYGXyU7FeqOv + mgkSwnYHQivQIpeAwgr20 + + _6528263073538749848.back mKpq3GwvJxRduE5RsGgGP + + .push_back miAECMSxGwjxrcOKk0DII + Point2f mhxtTU7dvZHXCTSg8B8rx + static_cast mYfYoOWdsOLTDCIBT7npX + + maOczvhF_v9OTsK70ZZut + + mE4_Vrik0lveh4HNJUk1B + + + miAECMSxGwjxrcOKk0DII + + + + + +_18125075577596139249 mTjppsgNpY1Pjyv5Z_zMr + + _13303058356268144139 mo8MRbS3DUX_ZOlgmUSna + + .x mmCJ670wA_VHgip7JZ1dW + + ,static_cast mYfYoOWdsOLTDCIBT7npX + + mnqZGwZqTTi1dekKxujAE + + + m_j6ZkbEfLCgUqtaolYTp + + + mReDuVelSknxaDAoDEmwT + + + +_18125075577596139249 mA4oXllup8K3T5dxkluRR + _13303058356268144139 mEFd2D2UDF9SIoPfQtUv6 .y mycwFs63h7Mi3ggRkMEVm + + + + msubWq7nTVSPilWqmTzkx + + mycwFs63h7Mi3ggRkMEVm + + mhGXMe8LHJXydR9dMisHj + + + + + + + mRzhpvoeHZK7yCqqzYDDp + mmmC9tOGiLK6UaJr0E5vz + + + + + _11520114173644902406 mlqM0snvYcrWCw2_QjhQi + + + mT_x8cqp5t43PgqNMR8gO + + _1548619269531313217 mhxtTU7dvZHXCTSg8B8rx + + + + _6528263073538749848.back maHkatHu0Jap4oTaT5q4_ + + + , mWokjWH0MHqyBOx4j0Oac + mFlVjO0mLpwnCN5a1Quio + + _15680653421411319497 mycwFs63h7Mi3ggRkMEVm + + + + + /2. muiDYQbmwLxL3PGrwWGeP + + + + + mdmuaUz9iCkCckSUhcEv1 + + mhl3Z6oGBbP13ZxehUcg9 + + +#ifdef _aruco_debug_detectrectangles + MarkerCanditates.back mKpq3GwvJxRduE5RsGgGP + + + +.draw mp3H4249LtCVDCYFqQqz4 + + +simage,Scalar mmmC9tOGiLK6UaJr0E5vz + + +255, 255, 0 muiDYQbmwLxL3PGrwWGeP + ,1, mEzFcmvX0IX3FOucgCcVF + + + +mycwFs63h7Mi3ggRkMEVm + + + mlqoNTA3LQoUJF6i5YDFc + + + + +#endif + _6528263073538749848.back mwTQhkbVNQHd2Xw4EA4fj + + .contourPoints mKcKHr_bTagXAK_pf8btG + + _10998538416191004035 mGYpOkNIG_qSvYXBOU9Vf + _13303058356268144138 mEFd2D2UDF9SIoPfQtUv6 + + mftnbgRvzOIVyL93HyyWt + + + + + + + + mCvAz6nTbqhvwRULRgKe4 + + + + + + + mnSkEvR4SbDwQxj23xB1M + + + + + muuG2jhk4iNsA9KNmj6oA + + +#ifdef _aruco_debug_detectrectangles + cv mEMN2sRTwHcTUl7SNSw0d + + + +imshow miAECMSxGwjxrcOKk0DII + + + "\x5c\x78\x36\x33\x5c\x78\x36\x66\x5c\x78\x36\x65\x5c\x78\x37\x34\x5c\x78\x36\x66\x5c\x78\x37\x35\x5c\x78\x37\x32\x5c\x78\x37\x33",simage mzf4ZxeZY8wF2XnrdYK61 + + mhGXMe8LHJXydR9dMisHj + +#endif + mlJqcdUT0sl1_64qaqDwc + + + + + + _6528263073538749848 mftnbgRvzOIVyL93HyyWt + + mICILgDpdCTDSJqQAn06L + + + + + mc6SGgM2Uzvo_wy5KTima + + MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + _1434268935998653744 miAECMSxGwjxrcOKk0DII + + mAnDeXfeHaujEzGBbrjil + mN0TszoCQmyzxmobsgV2H + + + + + while mReDuVelSknxaDAoDEmwT + + + + + m_lICnZ0bJGmuMACmMVcA + + mmCJ670wA_VHgip7JZ1dW + + mT_x8cqp5t43PgqNMR8gO + + + + mYA_OUCZSQycbIZ5oB16m + + + + + + _11520114173644902406 mdKhcOUXVqyCMdccisL_a + + + + mHbmZNNhradVwUtDZ5U7B + + + + + + mhGXMe8LHJXydR9dMisHj + + + m_6hetAMDOSYN9CmiL4W7 + + + + _5268611907606565765 muQdV4OJL6V6gVxW6AdRy + + _16684997543815802068._3970747861761939044 maHkatHu0Jap4oTaT5q4_ + + mVOlbMaOu1U0SC2oeKIzP + + mNhNSN2gx5KERe8tfdmgu + + + + + mp3H4249LtCVDCYFqQqz4 + + + + _5268611907606565765._1012033135676957631 mRuVXNtG32xpaNLi1hDLk + EXIT_TASK mycwFs63h7Mi3ggRkMEVm + + + + + mTAavMivNX5WuUrRQXoEf + mJTScPpWt8plE9Cz9fDU6 + + + + mHcxzZHoWX11H4xEjR59T + + + mEwOO8zzJcEkF96gfFa1e + + + + miAECMSxGwjxrcOKk0DII + + _5268611907606565765._1012033135676957631 mtPtbM6hNfOIkqlx661ci + + + +ENCLOSE_TASK mAnDeXfeHaujEzGBbrjil + + _11520114173644902406 mM3tRrWbRPqPOU3G4ShKT + + + mrRUZLmQTdeC3HO0hVmGH + + + + + + mhGXMe8LHJXydR9dMisHj + + + _8381292230366782771 mY2nz8M_6jpSxQZL8EYgU +_5268611907606565765._13074680784567168978 mrpQVzv6u8gxvho1qUlil + + + mM3tRrWbRPqPOU3G4ShKT + _11288135742209909849 mFsSEF_3_iD2mT6nZG9QR + + + + + + _16594497104544919971 mGYpOkNIG_qSvYXBOU9Vf + + + _5268611907606565765._9830224992155182763 msdqcdg5NNrdQnc_PT1Ee + + ,_5268611907606565765._13074680779112612408,_5268611907606565765._13074680779112612409,_11520114173644902406,_16594497104544919971 mTjppsgNpY1Pjyv5Z_zMr + _5268611907606565765._13074680784567168978 mo8MRbS3DUX_ZOlgmUSna + muiDYQbmwLxL3PGrwWGeP + + mVOlbMaOu1U0SC2oeKIzP + + + + + mhl3Z6oGBbP13ZxehUcg9 + + + + + + mxdAvfSsdzliezc0uyUMk + mnSkEvR4SbDwQxj23xB1M + + + + + +vector mbG1GEmOdh2dXkJZ42sXo + + + + +aruco mfx1fLYDWN4YRZNnQEsJN + MarkerDetector_Impl mBBHVSlvDGP5NVUfEuhuf + MarkerCandidate mE4_Vrik0lveh4HNJUk1B + + + + + MarkerDetector_Impl mU808frSKQDZnEEU3Q3s9 + + _11288135742209909849 mFsSEF_3_iD2mT6nZG9QR +const cv mU808frSKQDZnEEU3Q3s9 + + + + + + Mat &_17276674595339161488 mAnDeXfeHaujEzGBbrjil + mDzQQrEx5Ki0C6uDHU2cy + + + + + + + + meWm4MhzbcJwavtoh469w + + _11129164959907732555 muQdV4OJL6V6gVxW6AdRy + +_18062104616271777338.AdaptiveThresWindowSize mftnbgRvzOIVyL93HyyWt + + + mWHxIxEh8g9mg3Hyipn8D + + mp3H4249LtCVDCYFqQqz4 + + + +_18062104616271777338.AdaptiveThresWindowSize mZVOYp2JAGvUM7UPbzd3Q + + + + + + -1 msubWq7nTVSPilWqmTzkx + + _11129164959907732555 mRwjoMr_aqph4iL4nu8NS max mFlVjO0mLpwnCN5a1Quio mSD7jHYN8mOif4_CBtIg6 + mhORIPgMIfN3Fn8aCQBuU + + + + + + 3 mycwFs63h7Mi3ggRkMEVm + + + , mSD7jHYN8mOif4_CBtIg6 mFsSEF_3_iD2mT6nZG9QR + 15*float mp3H4249LtCVDCYFqQqz4 + + _17276674595339161488.cols mycwFs63h7Mi3ggRkMEVm + + + + /1920. mhyL_M5gnmQzwyHW45MdA + msubWq7nTVSPilWqmTzkx + + mlqoNTA3LQoUJF6i5YDFc + + + + mikiSyOnVry6pvQ1Ds28H + + _11129164959907732555%2 mHOvg7vOJH6ujsVsg3S5G + + + + + 0 mhyL_M5gnmQzwyHW45MdA _11129164959907732555 mkGHGzUDDVqHIjIdYGe6S + + + + + mftnbgRvzOIVyL93HyyWt + + + + vector mHkLXuUOlyX2vZI7w3FQj + + mG7mr0Iq8BCEeADSwrCoW + + +mE4_Vrik0lveh4HNJUk1B + + + + + + _17256916070189102836 mhGXMe8LHJXydR9dMisHj + + + + mNMDyj9J1Nt8auTKwp8ze + mReDuVelSknxaDAoDEmwT + moI11mwtxiOXpqDxK_aQL + + + + + + _13303058356268144138 myJHqW7fkn_72nVEhKeZ6 + + + static_cast mHkLXuUOlyX2vZI7w3FQj + mG7mr0Iq8BCEeADSwrCoW + mel3l7ZRXwnAEsy0Wfxj_ + + + mFsSEF_3_iD2mT6nZG9QR + + + + std mpJt2kGThF7wb3VNzG38b + + + + + max mFlVjO0mLpwnCN5a1Quio + 3., _11129164959907732555- 2. * _18062104616271777338.AdaptiveThresWindowSize_range mycwFs63h7Mi3ggRkMEVm + mmCJ670wA_VHgip7JZ1dW + + + mhGXMe8LHJXydR9dMisHj + + _13303058356268144138 mgSkXUgcRjYGUB2o3shqJ + + + + + _11129164959907732555 + 2 * _18062104616271777338.AdaptiveThresWindowSize_range mriCvhMavpfheoLNc0eCD + + + _13303058356268144138 msMfR3R5kzP8SqAQ3DWTq + + + + 2 mAnDeXfeHaujEzGBbrjil + + _17256916070189102836.push_back mp3H4249LtCVDCYFqQqz4 + + + _13303058356268144138 msubWq7nTVSPilWqmTzkx + mlqoNTA3LQoUJF6i5YDFc + + + + size_t _11244054752219786216 mCm219F3DHVwNe_CsrCeK + + + + + +_17256916070189102836.size mdWkXjuaPd4Se0r0SdY1e + + mdmuaUz9iCkCckSUhcEv1 + + + _11754215234869264027 mu_nOcTFwUo8r0uNE351R + + _17256916070189102836.back mbHCSQc_uaLNP9Sf4Lz_n + mPdHdcAZ6XJhwf8wLtULI + + + + + _8381292230366782771.resize mmmC9tOGiLK6UaJr0E5vz + + +_11244054752219786216 muiDYQbmwLxL3PGrwWGeP + + mPdHdcAZ6XJhwf8wLtULI + + + + + + + _16594497104544919971.resize mhORIPgMIfN3Fn8aCQBuU + + _11244054752219786216+1 mlqM0snvYcrWCw2_QjhQi + + mlqoNTA3LQoUJF6i5YDFc + + _16594497104544919971.back maHkatHu0Jap4oTaT5q4_ + + myJHqW7fkn_72nVEhKeZ6 + _17276674595339161488 mPdHdcAZ6XJhwf8wLtULI + + + + + + + + _15785113844694797795 _5268611907606565765 mdmuaUz9iCkCckSUhcEv1 + vector mK5OxIt23gZzSiTA8trU8 + _15785113844694797795 mEc9zv3P8LW8haIvtztwe + + + + + _3175889863520737153 mdmuaUz9iCkCckSUhcEv1 + + + + ThreadTasks _3176948232912920464 mCm219F3DHVwNe_CsrCeK + + THRESHOLD_TASK mINcNsH05D0QZDej9wl4h + + + + + mRzhpvoeHZK7yCqqzYDDp + + mSa4WnWih0z4lSo9RYUGU + + + + + _18062104616271777338.enclosedMarker mlqM0snvYcrWCw2_QjhQi + + + + + + _3176948232912920464 mdKhcOUXVqyCMdccisL_a + ENCLOSE_TASK mhGXMe8LHJXydR9dMisHj + mNMDyj9J1Nt8auTKwp8ze + + + + + mFsSEF_3_iD2mT6nZG9QR + + + + + + size_t _13303058356268144138 ma6VjqdfajK4BX9gkoGiD + + + 0 mftnbgRvzOIVyL93HyyWt + + + _13303058356268144138 mca1GaR7Rv9qOZsisqKBB + + + + _17256916070189102836.size mFwk30320retpLBiICndp + + mriCvhMavpfheoLNc0eCD _13303058356268144138 mt0bWs8kxCzTnBdtR9vKu + mzf4ZxeZY8wF2XnrdYK61 + + + + + + mDzQQrEx5Ki0C6uDHU2cy + _5268611907606565765._9830224992155182763 mif4ZCBkqdiqSYkR9AD0r mSD7jHYN8mOif4_CBtIg6 + + + +mhORIPgMIfN3Fn8aCQBuU _16594497104544919971.size mzeHK1hG1SYQMISNMWMB8 + + + + -1 mlqM0snvYcrWCw2_QjhQi + mINcNsH05D0QZDej9wl4h + + _5268611907606565765._13074680779112612408 mRwjoMr_aqph4iL4nu8NS + + + + + + _17256916070189102836 mdF98bHO7yrxGJn0aQZVK _13303058356268144138 mrpQVzv6u8gxvho1qUlil + + + + + + mriCvhMavpfheoLNc0eCD + + + + _5268611907606565765._13074680779112612409 mdKhcOUXVqyCMdccisL_a + _18062104616271777338.ThresHold mxdAvfSsdzliezc0uyUMk + + + + _5268611907606565765._13074680784567168978 ma6VjqdfajK4BX9gkoGiD + + + + + + _13303058356268144138 mJTScPpWt8plE9Cz9fDU6 + + _5268611907606565765._1012033135676957631 mM3tRrWbRPqPOU3G4ShKT + + + +_3176948232912920464 mdmuaUz9iCkCckSUhcEv1 + + + _16684997543815802068._16400045516394125907 mhxtTU7dvZHXCTSg8B8rx _5268611907606565765 mAnDeXfeHaujEzGBbrjil + + + + + + mriCvhMavpfheoLNc0eCD + + + + _3175889863520737153.push_back mReDuVelSknxaDAoDEmwT _5268611907606565765 mlqM0snvYcrWCw2_QjhQi + mdmuaUz9iCkCckSUhcEv1 + + + mDUyr1RAsHMG7u1BeTW3F + + + + + + + + + + mFrnvKb629IAbveEQOTJk + + + + size_t _13303058356268144138 mif4ZCBkqdiqSYkR9AD0r + + 0 mPdHdcAZ6XJhwf8wLtULI + + _13303058356268144138 mca1GaR7Rv9qOZsisqKBB + + _11244054752219786216 mJTScPpWt8plE9Cz9fDU6 + + + + _13303058356268144138 mBh4lc09qKYGXyU7FeqOv + + muiDYQbmwLxL3PGrwWGeP + + + + + _16594497104544919971 mA4oXllup8K3T5dxkluRR + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + + + + .create mFsSEF_3_iD2mT6nZG9QR + + + + + _17276674595339161488.size mzeHK1hG1SYQMISNMWMB8 + + + + + +,CV_8UC1 mAnDeXfeHaujEzGBbrjil + + + mhGXMe8LHJXydR9dMisHj + + + + + + + mdbRZP7cWFYlUcaGRMsKc + + + + + + _5547719957745377269 mM3tRrWbRPqPOU3G4ShKT + + + + + + 0 mxdAvfSsdzliezc0uyUMk + + mEwOO8zzJcEkF96gfFa1e + + + mhORIPgMIfN3Fn8aCQBuU + + _18062104616271777338.maxThreads mKbtq8OHrv8CI8FhvE4XG + + + + 0 muiDYQbmwLxL3PGrwWGeP + + + + _5547719957745377269 ma6VjqdfajK4BX9gkoGiD + + + std mEMN2sRTwHcTUl7SNSw0d + thread mEMN2sRTwHcTUl7SNSw0d + + +hardware_concurrency mdWkXjuaPd4Se0r0SdY1e -1 mINcNsH05D0QZDej9wl4h + + + + muKP5B7qysoQRrYrwu_aG + _5547719957745377269 mif4ZCBkqdiqSYkR9AD0r + + + max mFlVjO0mLpwnCN5a1Quio + 1,_18062104616271777338.maxThreads-1 mlqM0snvYcrWCw2_QjhQi + + mriCvhMavpfheoLNc0eCD + + _5268611907606565765._1012033135676957631 ma6VjqdfajK4BX9gkoGiD + + + + + + EXIT_TASK mftnbgRvzOIVyL93HyyWt + + mhXXYzAVu3lDYyh7TkRWq + + mdbRZP7cWFYlUcaGRMsKc + + _13303058356268144138 myJHqW7fkn_72nVEhKeZ6 + + + + 0 mdmuaUz9iCkCckSUhcEv1 + + _13303058356268144138 mqEAvVDOCXqrrwrTRByrM + _5547719957745377269 mJTScPpWt8plE9Cz9fDU6 _13303058356268144138 mBh4lc09qKYGXyU7FeqOv + + + + mXAYJa6osZ6HNTIEEBnr0 + + _16684997543815802068._16400045516394125907 mhxtTU7dvZHXCTSg8B8rx + + _5268611907606565765 mmCJ670wA_VHgip7JZ1dW + + + + mlqoNTA3LQoUJF6i5YDFc + + + + + + mabeHDqoCFUg5Mty5oLni + mmmC9tOGiLK6UaJr0E5vz + + + + + + _5547719957745377269 mnZ6t3BhMZ_1d7zzE72ah + + + 1 mmCJ670wA_VHgip7JZ1dW mjbtcSgN5ZQfkGDsoYG4l + + + ScopeTimer _15827673749496603388 mhxtTU7dvZHXCTSg8B8rx + + "\x5c\x78\x36\x65\x5c\x78\x36\x66\x5c\x78\x36\x65\x5c\x78\x32\x64\x5c\x78\x37\x30\x5c\x78\x36\x31\x5c\x78\x37\x32\x5c\x78\x36\x31\x5c\x78\x36\x63\x5c\x78\x36\x63\x5c\x78\x36\x35\x5c\x78\x36\x63" mgkSwnYHQivQIpeAwgr20 + + mINcNsH05D0QZDej9wl4h + + + + _1434268935998653744 mSa4WnWih0z4lSo9RYUGU + + mlqM0snvYcrWCw2_QjhQi + + + + mxdAvfSsdzliezc0uyUMk + + + + + + + mJOnXqKm3GBylSdRjpXAA + + + + mv1ijGQAKacWqWAusY8nc + + +mT_x8cqp5t43PgqNMR8gO + + ScopeTimer _15827673749496603388 mhxtTU7dvZHXCTSg8B8rx + + + +"\x5c\x78\x37\x30\x5c\x78\x36\x31\x5c\x78\x37\x32\x5c\x78\x36\x31\x5c\x78\x36\x63\x5c\x78\x36\x63\x5c\x78\x36\x35\x5c\x78\x36\x63" mlqM0snvYcrWCw2_QjhQi + + + + mlqoNTA3LQoUJF6i5YDFc + + + + + + vector mCALzjQ0bwpDnngl_oSsi + + std mU808frSKQDZnEEU3Q3s9 +thread mEc9zv3P8LW8haIvtztwe _1198931662437097535 mxdAvfSsdzliezc0uyUMk + + + + mhXXYzAVu3lDYyh7TkRWq + + + mMGij61UZUIIYyztVz9vN + _13303058356268144138 mCm219F3DHVwNe_CsrCeK + + + 0 mINcNsH05D0QZDej9wl4h + _13303058356268144138 mlP1m6taP4mQVYA_j8Oxe + + + + + _5547719957745377269 mJTScPpWt8plE9Cz9fDU6 + + _13303058356268144138 mo7mKuzaX2h9vw2rEj5qh + mgkSwnYHQivQIpeAwgr20 + + + + + _1198931662437097535.push_back mp3H4249LtCVDCYFqQqz4 + + std mU808frSKQDZnEEU3Q3s9 + + + + + + thread mSa4WnWih0z4lSo9RYUGU + + &MarkerDetector_Impl maKLz6mCz5anFyVle_MtD + + + _1434268935998653744, this mmCJ670wA_VHgip7JZ1dW + mycwFs63h7Mi3ggRkMEVm + + + mPdHdcAZ6XJhwf8wLtULI + + + + mF9AQyKXtPTPy1zvAUpED + mF8CPQI5IssWjwlV2CXVE + + + + + + &_16232574195041814781:_1198931662437097535 mhyL_M5gnmQzwyHW45MdA + + + + + + _16232574195041814781.join mcznTYeCGOAygtXXAPYS_ + mPdHdcAZ6XJhwf8wLtULI + + + + + mCvAz6nTbqhvwRULRgKe4 + + + + + vector mlP1m6taP4mQVYA_j8Oxe + + MarkerCandidate m_j6ZkbEfLCgUqtaolYTp + + + + _1696087129052635781 mVOlbMaOu1U0SC2oeKIzP + + + + + _9674227328620005286 mSa4WnWih0z4lSo9RYUGU + + _8381292230366782771,_1696087129052635781 mAnDeXfeHaujEzGBbrjil + + mVOlbMaOu1U0SC2oeKIzP + + + + + + + mow1IjdflpN81ICD702rC + + + _1696087129052635781 mPdHdcAZ6XJhwf8wLtULI + + + mnSkEvR4SbDwQxj23xB1M + + + +vector mCALzjQ0bwpDnngl_oSsi + + MarkerDetector_Impl mU808frSKQDZnEEU3Q3s9 + MarkerCandidate mW1YUos9eL_9NmgJuSDH7 + MarkerDetector_Impl maKLz6mCz5anFyVle_MtD + _17990657514663812703 mReDuVelSknxaDAoDEmwT + + + + vector mHkLXuUOlyX2vZI7w3FQj + aruco mpJt2kGThF7wb3VNzG38b + + + MarkerDetector_Impl mpJt2kGThF7wb3VNzG38b + + + + MarkerCandidate mRHNkLPwUSnx20pmLgrTq + + &_6528263073538749848,cv mYGfQUZmV9IjKAPVrLhZl + + + Size _13182630212586469335 mzf4ZxeZY8wF2XnrdYK61 + + + + mypSy3lS4LRIjRYTxVxzg + + + + + + valarray mK5OxIt23gZzSiTA8trU8 + + + mpHTdkvfapV5_Igrm_XSs + mE4_Vrik0lveh4HNJUk1B + + + + + _2262480597151600831 mp3H4249LtCVDCYFqQqz4 + + false, _6528263073538749848.size mbHCSQc_uaLNP9Sf4Lz_n + + mhyL_M5gnmQzwyHW45MdA + + + + + + mriCvhMavpfheoLNc0eCD + + + + mLBxgVrVeq7bTUcDGJqNH + + mhORIPgMIfN3Fn8aCQBuU + + unsigned mdEzmAkZNQkKD1HrLnSSo +_13303058356268144138 mu_nOcTFwUo8r0uNE351R + + + + 0 mftnbgRvzOIVyL93HyyWt + + _13303058356268144138 mca1GaR7Rv9qOZsisqKBB + + _6528263073538749848.size mwTQhkbVNQHd2Xw4EA4fj + + + + + + mriCvhMavpfheoLNc0eCD + + + + + + _13303058356268144138 mt0bWs8kxCzTnBdtR9vKu + + mAnDeXfeHaujEzGBbrjil + + + + mypSy3lS4LRIjRYTxVxzg + + + + + mvfKgFvXHh0Jqv_PZxbka + + + + _5268605236564839919 mif4ZCBkqdiqSYkR9AD0r + + + + _6528263073538749848 mdF98bHO7yrxGJn0aQZVK + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + mILaQGKCAmcKrYQNhgWUq + + + 1 mUB1yrSrKOwldqxmCatN2 + .x - _6528263073538749848 mA4oXllup8K3T5dxkluRR + + + + + + _13303058356268144138 mrpQVzv6u8gxvho1qUlil + mTjppsgNpY1Pjyv5Z_zMr + + 0 mEFd2D2UDF9SIoPfQtUv6 + + + + .x mhGXMe8LHJXydR9dMisHj + + + + + + + mVPyhnVeODFpKcj5PAnUM +_5268605236564808364 mdKhcOUXVqyCMdccisL_a _6528263073538749848 mA4oXllup8K3T5dxkluRR + +_13303058356268144138 mUB1yrSrKOwldqxmCatN2 + + + + mTjppsgNpY1Pjyv5Z_zMr + + + + 1 mDd5IIsnjfLI1lcygRsW3 + + .y - _6528263073538749848 mNDJrNgMXB1tBoFNaJO0d + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + + + mY2nz8M_6jpSxQZL8EYgU + 0 mrpQVzv6u8gxvho1qUlil + + + + + +.y mlqoNTA3LQoUJF6i5YDFc + + + + + mKui3FcBrQ5fUw3SS2JBl + _5268605236564839891 mu_nOcTFwUo8r0uNE351R + _6528263073538749848 mTjppsgNpY1Pjyv5Z_zMr _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee + + mWkGo8xUdRIKgJ1DEUvvn + 2 mEFd2D2UDF9SIoPfQtUv6 + + + + + + .x - _6528263073538749848 mFyKKLtdivGGDlk8sYzsf + + + + + + _13303058356268144138 mbViqhyIcr6lGWibuo3Im mTjppsgNpY1Pjyv5Z_zMr + + + +0 msdqcdg5NNrdQnc_PT1Ee + .x mVOlbMaOu1U0SC2oeKIzP + + mvfKgFvXHh0Jqv_PZxbka _5268605236564808430 mdKhcOUXVqyCMdccisL_a + + _6528263073538749848 mGYpOkNIG_qSvYXBOU9Vf + + + + + + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + + + mdF98bHO7yrxGJn0aQZVK + + + 2 mwTp2D1d4PfxNNOzzUfhS + + + + .y - _6528263073538749848 mdF98bHO7yrxGJn0aQZVK + + _13303058356268144138 mrpQVzv6u8gxvho1qUlil + mZnfmoDANjVLDjZfzM5MR + + 0 mwTp2D1d4PfxNNOzzUfhS + + + + + + .y mdmuaUz9iCkCckSUhcEv1 + + + + + + + mqwYu0y4oTPCnfXbylThX + + + _13303058356268144086 mRwjoMr_aqph4iL4nu8NS + + + + mhxtTU7dvZHXCTSg8B8rx _5268605236564839919 * _5268605236564808430 muiDYQbmwLxL3PGrwWGeP + - mp3H4249LtCVDCYFqQqz4 _5268605236564808364 * _5268605236564839891 mlqM0snvYcrWCw2_QjhQi + + + + mriCvhMavpfheoLNc0eCD + + + + + + mabeHDqoCFUg5Mty5oLni + + + + mtbP4KQJdh36UGELfV2zq + _13303058356268144086 mYfYoOWdsOLTDCIBT7npX + + + + + 0.0 mmCJ670wA_VHgip7JZ1dW + + + + + + + mfKhTg3wpiK_YhdQzWWcS + + + + swap mReDuVelSknxaDAoDEmwT + + _6528263073538749848 mWkGo8xUdRIKgJ1DEUvvn + + + + + + _13303058356268144138 mrpQVzv6u8gxvho1qUlil + + mA4oXllup8K3T5dxkluRR 1 mrpQVzv6u8gxvho1qUlil + + +, _6528263073538749848 mGYpOkNIG_qSvYXBOU9Vf + + + _13303058356268144138 mUB1yrSrKOwldqxmCatN2 + + + + + + mGYpOkNIG_qSvYXBOU9Vf + 3 mJtGCV8zXQjnVDVBVdvFZ + + + + + + mlqM0snvYcrWCw2_QjhQi mPdHdcAZ6XJhwf8wLtULI + + _2262480597151600831 mNDJrNgMXB1tBoFNaJO0d + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + mM3tRrWbRPqPOU3G4ShKT + + mqQspPZKCoa6LP0Jj0qH2 + + mlqoNTA3LQoUJF6i5YDFc + + + + + mhl3Z6oGBbP13ZxehUcg9 + + + + + maCQ9r5fSln_CXgRXGFvO + + + + vector mW1ds9XwNwevT5B2b3j8B + + + + + + pair mK5OxIt23gZzSiTA8trU8 + int, mG7mr0Iq8BCEeADSwrCoW mgWtxscBTuWBkK7X3fJ_M + + + + + + _2458634995200666860 mdmuaUz9iCkCckSUhcEv1 + mxQewHEnT8PTNQcVKCqL9 + + + + mSa4WnWih0z4lSo9RYUGU + + + + + +unsigned mihBlyb7pwidO496a5_p1 _13303058356268144138 mM3tRrWbRPqPOU3G4ShKT + + + + 0 mVOlbMaOu1U0SC2oeKIzP + + + + _13303058356268144138 mca1GaR7Rv9qOZsisqKBB + + _6528263073538749848.size mKpq3GwvJxRduE5RsGgGP + + mriCvhMavpfheoLNc0eCD + + + + + _13303058356268144138 mEZrtAN7pSZl5y4oEHd38 + + + mAnDeXfeHaujEzGBbrjil + + + mjbtcSgN5ZQfkGDsoYG4l + + mA9OyoOle98msK0BnFc8I + + + + mhxtTU7dvZHXCTSg8B8rx + + +unsigned meWm4MhzbcJwavtoh469w + + _13303058356268144139 mRwjoMr_aqph4iL4nu8NS + + + _13303058356268144138 + 1 mxdAvfSsdzliezc0uyUMk _13303058356268144139 mCALzjQ0bwpDnngl_oSsi + + + + + + _6528263073538749848.size mbHCSQc_uaLNP9Sf4Lz_n + + + + + + mJTScPpWt8plE9Cz9fDU6 + + + _13303058356268144139 mo7mKuzaX2h9vw2rEj5qh mXAYJa6osZ6HNTIEEBnr0 + + + + + mjbtcSgN5ZQfkGDsoYG4l + + + valarray mca1GaR7Rv9qOZsisqKBB + + + + + mglDNKH5ah89GptW6H4Cu mRHNkLPwUSnx20pmLgrTq + _11909273676365498091 mSa4WnWih0z4lSo9RYUGU + + 4 mgkSwnYHQivQIpeAwgr20 + + + + mhGXMe8LHJXydR9dMisHj + + + + mHIh6WyQKJh1ZKme1nslP + + + + + + mtbP4KQJdh36UGELfV2zq + + meWm4MhzbcJwavtoh469w + + + + _13303058356268144199 myJHqW7fkn_72nVEhKeZ6 + 0 mlqoNTA3LQoUJF6i5YDFc + + + _13303058356268144199 mK5OxIt23gZzSiTA8trU8 + + + + + + 4 mINcNsH05D0QZDej9wl4h + + + + _13303058356268144199 mo7mKuzaX2h9vw2rEj5qh + + muiDYQbmwLxL3PGrwWGeP + + _11909273676365498091 mY2nz8M_6jpSxQZL8EYgU + + + _13303058356268144199 msdqcdg5NNrdQnc_PT1Ee + + mu_nOcTFwUo8r0uNE351R + + + cv mpJt2kGThF7wb3VNzG38b + norm mFsSEF_3_iD2mT6nZG9QR + _6528263073538749848 mILaQGKCAmcKrYQNhgWUq + + + + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna mILaQGKCAmcKrYQNhgWUq + _13303058356268144199 mo8MRbS3DUX_ZOlgmUSna + + -_6528263073538749848 mdF98bHO7yrxGJn0aQZVK + + _13303058356268144139 mEFd2D2UDF9SIoPfQtUv6 + + mZnfmoDANjVLDjZfzM5MR + + + + + _13303058356268144199 mUB1yrSrKOwldqxmCatN2 + + + + + mgkSwnYHQivQIpeAwgr20 + mdmuaUz9iCkCckSUhcEv1 + + + + + + + mNhNSN2gx5KERe8tfdmgu + + + mmmC9tOGiLK6UaJr0E5vz + + + + + _11909273676365498091 mZnfmoDANjVLDjZfzM5MR + + + + + + 0 mo8MRbS3DUX_ZOlgmUSna + mYI2nkSxgJHf1pY1PttV1 + + + + _11754215234869264027 mBJ7M0ikk98KhD4Oi32wB + + + + _11909273676365498091 mGYpOkNIG_qSvYXBOU9Vf + + + + +1 mJtGCV8zXQjnVDVBVdvFZ + + + + + mCALzjQ0bwpDnngl_oSsi + _11754215234869264027 mBJ7M0ikk98KhD4Oi32wB + + _11909273676365498091 mZnfmoDANjVLDjZfzM5MR + + + 2 mUB1yrSrKOwldqxmCatN2 + + mYI2nkSxgJHf1pY1PttV1 + _11754215234869264027 mBJ7M0ikk98KhD4Oi32wB + + _11909273676365498091 mA4oXllup8K3T5dxkluRR + + +3 mo8MRbS3DUX_ZOlgmUSna + + + mYfYoOWdsOLTDCIBT7npX + + + + _11754215234869264027 mmCJ670wA_VHgip7JZ1dW + + _2458634995200666860.push_back mmmC9tOGiLK6UaJr0E5vz + + +pair mqEAvVDOCXqrrwrTRByrM + int, mSD7jHYN8mOif4_CBtIg6 mel3l7ZRXwnAEsy0Wfxj_ + + + mhxtTU7dvZHXCTSg8B8rx + _13303058356268144138, _13303058356268144139 mlqM0snvYcrWCw2_QjhQi + + mmCJ670wA_VHgip7JZ1dW + + + mxdAvfSsdzliezc0uyUMk + + + + + + + mnSkEvR4SbDwQxj23xB1M + + + + + mJOnXqKm3GBylSdRjpXAA + + + + + + + vector mYfYoOWdsOLTDCIBT7npX + + + + mcqTciDcDgSbPPY9iuwhB + + + + mYxohqgekcJ8HhaDZvWcX + + + + _7127668893958858208 mmmC9tOGiLK6UaJr0E5vz + + + + + + _6528263073538749848.size mKpq3GwvJxRduE5RsGgGP , mVgd0sC5KIFeGa4mcMXm9 + + + muiDYQbmwLxL3PGrwWGeP mINcNsH05D0QZDej9wl4h + + + + + + m_owRLEm0gIJ4StPRwTkZ + + + mhORIPgMIfN3Fn8aCQBuU + + + unsigned mMGij61UZUIIYyztVz9vN + + + + _13303058356268144138 mRwjoMr_aqph4iL4nu8NS + + + + 0 mxdAvfSsdzliezc0uyUMk + _13303058356268144138 mqEAvVDOCXqrrwrTRByrM + + + + _2458634995200666860.size mH1xQMRmYb0Y4RDp2hARz + + + + + + mhGXMe8LHJXydR9dMisHj + + + _13303058356268144138 mkGHGzUDDVqHIjIdYGe6S + + + + mgkSwnYHQivQIpeAwgr20 + + + mfKhTg3wpiK_YhdQzWWcS + + mMNJIG0z6TLGgbjrhllmy + + mmmC9tOGiLK6UaJr0E5vz + _16109434691388891984 mhxtTU7dvZHXCTSg8B8rx + _6528263073538749848 mA4oXllup8K3T5dxkluRR + + + _2458634995200666860 mGYpOkNIG_qSvYXBOU9Vf + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + + + + .first mEFd2D2UDF9SIoPfQtUv6 + + + + mhyL_M5gnmQzwyHW45MdA mE4_Vrik0lveh4HNJUk1B + _16109434691388891984 mmmC9tOGiLK6UaJr0E5vz + + + _6528263073538749848 mFyKKLtdivGGDlk8sYzsf + + _2458634995200666860 mA4oXllup8K3T5dxkluRR + + + +_13303058356268144138 mrpQVzv6u8gxvho1qUlil + + .second mIkhxhgSNMt_JUZR7ce1U + + + + + mXAYJa6osZ6HNTIEEBnr0 mycwFs63h7Mi3ggRkMEVm + + + + _7127668893958858208 mA4oXllup8K3T5dxkluRR + + + + _2458634995200666860 mTjppsgNpY1Pjyv5Z_zMr + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + .second mIkhxhgSNMt_JUZR7ce1U + + + + + + mdKhcOUXVqyCMdccisL_a + + + mCAzyIDtopeLXRxFfI0EK + + + + +mxdAvfSsdzliezc0uyUMk + + + else + _7127668893958858208 mTjppsgNpY1Pjyv5Z_zMr + + _2458634995200666860 mFyKKLtdivGGDlk8sYzsf + + + + _13303058356268144138 mbViqhyIcr6lGWibuo3Im .first mbViqhyIcr6lGWibuo3Im + + mKcKHr_bTagXAK_pf8btG + + mqQspPZKCoa6LP0Jj0qH2 + + mxdAvfSsdzliezc0uyUMk + + mbYMUxVFybbviIFqRhN2f + + + + + + + + + + mP8l6554fUQhsCw2PetD2 + _385327363244837679 mCm219F3DHVwNe_CsrCeK + static_cast mYI2nkSxgJHf1pY1PttV1 mdbRZP7cWFYlUcaGRMsKc + + + + + + mEc9zv3P8LW8haIvtztwe + + mhORIPgMIfN3Fn8aCQBuU + + _18062104616271777338.borderDistThres * mglDNKH5ah89GptW6H4Cu + + + miAECMSxGwjxrcOKk0DII + + + _13182630212586469335.width muiDYQbmwLxL3PGrwWGeP mzf4ZxeZY8wF2XnrdYK61 + + mxdAvfSsdzliezc0uyUMk + + + + + + + mCujczJix6jMpJcynoBiA + + + _385327363244837678 muQdV4OJL6V6gVxW6AdRy + + + static_cast mHkLXuUOlyX2vZI7w3FQj + + mCujczJix6jMpJcynoBiA + + mjxPa00ei9qkuuQmiGB3C + + + mFlVjO0mLpwnCN5a1Quio + + _18062104616271777338.borderDistThres * mnECjbnhLknZie3Z5iHP2 + + + + mSa4WnWih0z4lSo9RYUGU + + _13182630212586469335.height mgkSwnYHQivQIpeAwgr20 + + mlqM0snvYcrWCw2_QjhQi + + + + mINcNsH05D0QZDej9wl4h + + + + + + + maB_pNl4zuODt3oqXg9EB + + + + mFsSEF_3_iD2mT6nZG9QR + + + + + + size_t _13303058356268144138 myJHqW7fkn_72nVEhKeZ6 + + + + + + 0 mftnbgRvzOIVyL93HyyWt + _13303058356268144138 mYI2nkSxgJHf1pY1PttV1 + + _6528263073538749848.size mwTQhkbVNQHd2Xw4EA4fj + + + + + mriCvhMavpfheoLNc0eCD + + + _13303058356268144138 mkGHGzUDDVqHIjIdYGe6S + mycwFs63h7Mi3ggRkMEVm + + mnU2hwoI16_nZ7reLKJTr + + + + + m_BNZbnU2Y1bOBnnPOF0b + + + mhxtTU7dvZHXCTSg8B8rx + + size_t _13303058356268144199 mM3tRrWbRPqPOU3G4ShKT 0 mlqoNTA3LQoUJF6i5YDFc + + + + _13303058356268144199 mYfYoOWdsOLTDCIBT7npX + + _6528263073538749848 mTjppsgNpY1Pjyv5Z_zMr + + + + _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee .size mzeHK1hG1SYQMISNMWMB8 + + + mftnbgRvzOIVyL93HyyWt + + _13303058356268144199 mUq8qfNXjDE9FPlMHvjf4 + + + + + + mycwFs63h7Mi3ggRkMEVm + + + + + mjbtcSgN5ZQfkGDsoYG4l + + + + mJvv2tbrel2xOYjvgipUL mmmC9tOGiLK6UaJr0E5vz _6528263073538749848 mGYpOkNIG_qSvYXBOU9Vf + + + + _13303058356268144138 mDd5IIsnjfLI1lcygRsW3 + mY2nz8M_6jpSxQZL8EYgU + + + + + + _13303058356268144199 mo8MRbS3DUX_ZOlgmUSna + + + + .x mYI2nkSxgJHf1pY1PttV1 + _385327363244837679 mQfgxxEXCA984FTu8Jz8Q + + + _6528263073538749848 mFyKKLtdivGGDlk8sYzsf _13303058356268144138 mUB1yrSrKOwldqxmCatN2 + + + + mILaQGKCAmcKrYQNhgWUq + + +_13303058356268144199 mUB1yrSrKOwldqxmCatN2 + + + + .y mlP1m6taP4mQVYA_j8Oxe + + + + _385327363244837678 + mRawsH1LNxMcHXhyroWR7 + _6528263073538749848 mILaQGKCAmcKrYQNhgWUq + + + + + _13303058356268144138 mDd5IIsnjfLI1lcygRsW3 + + + + + + mTjppsgNpY1Pjyv5Z_zMr + _13303058356268144199 mIkhxhgSNMt_JUZR7ce1U + .x mEc9zv3P8LW8haIvtztwe + + + _13182630212586469335.width - _385327363244837679 + mfNhxMALMjy2jMKPPP3pN + _6528263073538749848 mWkGo8xUdRIKgJ1DEUvvn + + + + + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + + mdF98bHO7yrxGJn0aQZVK _13303058356268144199 mbViqhyIcr6lGWibuo3Im + .y mRHNkLPwUSnx20pmLgrTq + + _13182630212586469335.height - _385327363244837678 mhyL_M5gnmQzwyHW45MdA + + mfKhTg3wpiK_YhdQzWWcS + + _7127668893958858208 mILaQGKCAmcKrYQNhgWUq + + _13303058356268144138 mEFd2D2UDF9SIoPfQtUv6 + + + + + + mif4ZCBkqdiqSYkR9AD0r + + + + mqQspPZKCoa6LP0Jj0qH2 + + + + + mriCvhMavpfheoLNc0eCD + + mgjPImSFwUcUKl9XTKqqB + + + + + + + maCQ9r5fSln_CXgRXGFvO + + mICILgDpdCTDSJqQAn06L + + + + + + vector mlP1m6taP4mQVYA_j8Oxe + + + +MarkerCandidate m_j6ZkbEfLCgUqtaolYTp + + _2164298203324692274 mlqoNTA3LQoUJF6i5YDFc + + + + + _2164298203324692274.reserve mmmC9tOGiLK6UaJr0E5vz + + + + _6528263073538749848.size mzeHK1hG1SYQMISNMWMB8 + mhyL_M5gnmQzwyHW45MdA + + mdmuaUz9iCkCckSUhcEv1 + + + + + + moPdTa5HpJKbS1U6TqDjY + + + + +size_t _13303058356268144138 mRwjoMr_aqph4iL4nu8NS + + + + 0 mhGXMe8LHJXydR9dMisHj + + _13303058356268144138 mW1ds9XwNwevT5B2b3j8B _6528263073538749848.size mcznTYeCGOAygtXXAPYS_ + + + + mdmuaUz9iCkCckSUhcEv1 + + + + + + _13303058356268144138 mcstdE8Wwpam6tUMM45Sa + + + mmCJ670wA_VHgip7JZ1dW + + + mwQUfI7G4pBH6IJQiBjmU + + + mFsSEF_3_iD2mT6nZG9QR + mRltbJjpZ8AzImbP6r6M4 + + + +_7127668893958858208 mA4oXllup8K3T5dxkluRR + + _13303058356268144138 mEFd2D2UDF9SIoPfQtUv6 + + + + + mycwFs63h7Mi3ggRkMEVm + + + + + + _2164298203324692274.push_back mSa4WnWih0z4lSo9RYUGU + _6528263073538749848 mNDJrNgMXB1tBoFNaJO0d + _13303058356268144138 mJtGCV8zXQjnVDVBVdvFZ mAnDeXfeHaujEzGBbrjil + + mhGXMe8LHJXydR9dMisHj + + + myYaYWcsrnLoe6SxorDYt + + + + + + _2164298203324692274 mftnbgRvzOIVyL93HyyWt + + + + + + + mJOnXqKm3GBylSdRjpXAA + + + mwu5s8ye7pYEdPIYXjU5h + + MarkerDetector_Impl mfx1fLYDWN4YRZNnQEsJN + + _6617398332792794799 mhORIPgMIfN3Fn8aCQBuU + + + cv myuwTFtkH1L5Be2OVY9rt + + + + Mat &_16232574195069562408,std mU808frSKQDZnEEU3Q3s9 + + + + + + vector mlP1m6taP4mQVYA_j8Oxe + + mglDNKH5ah89GptW6H4Cu + + + mjxPa00ei9qkuuQmiGB3C + + + &_3176948232212421105 mgkSwnYHQivQIpeAwgr20 + + + + mjbtcSgN5ZQfkGDsoYG4l + + + + mFrnvKb629IAbveEQOTJk + mdbRZP7cWFYlUcaGRMsKc + + + _13303058356268144023 mif4ZCBkqdiqSYkR9AD0r 0 mxdAvfSsdzliezc0uyUMk + + + + _13303058356268144023 mK5OxIt23gZzSiTA8trU8 + + _16232574195069562408.rows mlqoNTA3LQoUJF6i5YDFc _13303058356268144023 mwwJvnj2j3yLmklxxOEJQ + + + + mhyL_M5gnmQzwyHW45MdA + + + + mDzQQrEx5Ki0C6uDHU2cy + + + + uchar*_5268605234499577910 mu_nOcTFwUo8r0uNE351R + + _16232574195069562408.ptr mK5OxIt23gZzSiTA8trU8 + + + + + + uchar mEc9zv3P8LW8haIvtztwe + + + + mReDuVelSknxaDAoDEmwT + _13303058356268144023 muiDYQbmwLxL3PGrwWGeP + mVOlbMaOu1U0SC2oeKIzP + + + mFrnvKb629IAbveEQOTJk + + + + + + mdbRZP7cWFYlUcaGRMsKc + _13303058356268144065 mM3tRrWbRPqPOU3G4ShKT + + + + + +0 mxdAvfSsdzliezc0uyUMk + + + + + + _13303058356268144065 mbG1GEmOdh2dXkJZ42sXo + + + + + + _16232574195069562408.cols mlqoNTA3LQoUJF6i5YDFc + + + + + + _13303058356268144065 mEZrtAN7pSZl5y4oEHd38 + mycwFs63h7Mi3ggRkMEVm + + + + + + + _3176948232212421105 mA4oXllup8K3T5dxkluRR + + + + + + _5268605234499577910 mZnfmoDANjVLDjZfzM5MR + + + + + + _13303058356268144065 mo8MRbS3DUX_ZOlgmUSna mJtGCV8zXQjnVDVBVdvFZ + + + + + mt0bWs8kxCzTnBdtR9vKu + + mriCvhMavpfheoLNc0eCD + + + + maCQ9r5fSln_CXgRXGFvO + + + + + mhl3Z6oGBbP13ZxehUcg9 + + + mihBlyb7pwidO496a5_p1 + + MarkerDetector_Impl mYGfQUZmV9IjKAPVrLhZl + _5695532316837479313 mmmC9tOGiLK6UaJr0E5vz + + std mpJt2kGThF7wb3VNzG38b + + + + + + vector mK5OxIt23gZzSiTA8trU8 + + + + + + mnECjbnhLknZie3Z5iHP2 + + + + + + mEc9zv3P8LW8haIvtztwe + + + + + + &_3176948232212421105 mlqM0snvYcrWCw2_QjhQi + + mDzQQrEx5Ki0C6uDHU2cy + + mnqZGwZqTTi1dekKxujAE + + + _5268611907573087124 mM3tRrWbRPqPOU3G4ShKT + +0,_1677675503431562703 mftnbgRvzOIVyL93HyyWt + + + + + + + ma9rnYFEs_TUiw_WyBflg + mjc_6rRmys9smvg_opA48 + + + +_13303058356268144199:_3176948232212421105 mXAYJa6osZ6HNTIEEBnr0 + + _5268611907573087124 mYwsOAvDOXneTzOST0d5c + + + _13303058356268144199 mdmuaUz9iCkCckSUhcEv1 + + + + _1677675503431562703 muQdV4OJL6V6gVxW6AdRy + + 1./_5268611907573087124 mlqoNTA3LQoUJF6i5YDFc + + + + mhXXYzAVu3lDYyh7TkRWq + + myYAiLHDT3JvFKUJCC_FN + + + + +&_13303058356268144199:_3176948232212421105 mmCJ670wA_VHgip7JZ1dW + + + + _13303058356268144199 meZ135JJTidHY5m2MSApS + + + _1677675503431562703 mxdAvfSsdzliezc0uyUMk + + + + maISPbNJKXWB2QqsuuExM + _17126222195760917357 mRwjoMr_aqph4iL4nu8NS + + + + 0 mftnbgRvzOIVyL93HyyWt + + mMGij61UZUIIYyztVz9vN + + + + +_12512858585554741740 mu_nOcTFwUo8r0uNE351R + -1 mJTScPpWt8plE9Cz9fDU6 + + + mVRbVdVjFvNmKzGv4WiNp + mSD7jHYN8mOif4_CBtIg6 + _13303058356268144077 mKcKHr_bTagXAK_pf8btG + + + 1 mdmuaUz9iCkCckSUhcEv1 + + + _13303058356268144077 mca1GaR7Rv9qOZsisqKBB + + 256 mINcNsH05D0QZDej9wl4h + + + + + +_13303058356268144077 mt0bWs8kxCzTnBdtR9vKu + + + + + + mAnDeXfeHaujEzGBbrjil + + + + mMRNM5hfPBWFjYCspldu3 + mYKwa_OYBeVXzRPMa_mz6 + + _16232574195069208184 muQdV4OJL6V6gVxW6AdRy + 0,_16232574195069208185 mdKhcOUXVqyCMdccisL_a + 0,_15915682081708138341 mRwjoMr_aqph4iL4nu8NS + 0,_15915682081708138340 mKcKHr_bTagXAK_pf8btG + + + + + + 0 mPdHdcAZ6XJhwf8wLtULI + + + mwkUVn0D8pUxgFq_rx20G + + mCujczJix6jMpJcynoBiA + + _13303058356268144079 mdKhcOUXVqyCMdccisL_a 0 mftnbgRvzOIVyL93HyyWt + + _13303058356268144079 mYfYoOWdsOLTDCIBT7npX + + _13303058356268144077 mlqoNTA3LQoUJF6i5YDFc + + + + + + _13303058356268144079 mwwJvnj2j3yLmklxxOEJQ + + mXAYJa6osZ6HNTIEEBnr0 + + mDzQQrEx5Ki0C6uDHU2cy + + + + + + _16232574195069208184 mIzujDpHjrUPsW3ssOAji + + + + + + _3176948232212421105 mGYpOkNIG_qSvYXBOU9Vf + + + + + + _13303058356268144079 mEFd2D2UDF9SIoPfQtUv6 + mriCvhMavpfheoLNc0eCD + + + _15915682081708138341 mCAk2bmH5F7oeetankJLO mnECjbnhLknZie3Z5iHP2 + + + +mReDuVelSknxaDAoDEmwT + _13303058356268144079 muiDYQbmwLxL3PGrwWGeP *_3176948232212421105 mA4oXllup8K3T5dxkluRR + + + + _13303058356268144079 mIkhxhgSNMt_JUZR7ce1U mdmuaUz9iCkCckSUhcEv1 + + + + + mnSkEvR4SbDwQxj23xB1M + + mF9AQyKXtPTPy1zvAUpED + + + + mSD7jHYN8mOif4_CBtIg6 + + + + _13303058356268144079 mCm219F3DHVwNe_CsrCeK + + + + _13303058356268144077 mftnbgRvzOIVyL93HyyWt + + _13303058356268144079 mCALzjQ0bwpDnngl_oSsi + 256 mINcNsH05D0QZDej9wl4h + + _13303058356268144079 mnlCUtQ6kn1Qc7HkEzE0c + mycwFs63h7Mi3ggRkMEVm + mN0TszoCQmyzxmobsgV2H + + + _16232574195069208185 mce_8CnsU6ESSZfDxaV3C + + _3176948232212421105 mY2nz8M_6jpSxQZL8EYgU + +_13303058356268144079 mDd5IIsnjfLI1lcygRsW3 + + + + mINcNsH05D0QZDej9wl4h + + + + _15915682081708138340 mCAk2bmH5F7oeetankJLO + _3176948232212421105 mFyKKLtdivGGDlk8sYzsf + + + + + + _13303058356268144079 mrpQVzv6u8gxvho1qUlil + + *float mp3H4249LtCVDCYFqQqz4 + _13303058356268144079 mgkSwnYHQivQIpeAwgr20 + mriCvhMavpfheoLNc0eCD + + + + + + + maCQ9r5fSln_CXgRXGFvO + + + + + + + mWHxIxEh8g9mg3Hyipn8D + + + + mhxtTU7dvZHXCTSg8B8rx _16232574195069208184 mBpPKNB5wfuTOV223BA2r + + + + + + 1e-4 mECamByxBqjGyTShbPlRQ + + + _16232574195069208185 mEc9zv3P8LW8haIvtztwe + + +1e-4 mycwFs63h7Mi3ggRkMEVm + mjbtcSgN5ZQfkGDsoYG4l + + + _15915682081708138341 mmhvewuTDMRQuh4yozZj0 + + + + + + _16232574195069208184 mhGXMe8LHJXydR9dMisHj + + _15915682081708138340 mC854TxsErP91YgtWBjLs + _16232574195069208185 mVOlbMaOu1U0SC2oeKIzP + + + + + mI_QuD605u2H3qQFyuTju + + + _5268608556792470480 myJHqW7fkn_72nVEhKeZ6 + + + + + + _16232574195069208184*_16232574195069208185* miAECMSxGwjxrcOKk0DII + _15915682081708138341-_15915682081708138340 muiDYQbmwLxL3PGrwWGeP + * mp3H4249LtCVDCYFqQqz4 _15915682081708138341-_15915682081708138340 mXAYJa6osZ6HNTIEEBnr0 + + mriCvhMavpfheoLNc0eCD + + + + mWHxIxEh8g9mg3Hyipn8D + + mhORIPgMIfN3Fn8aCQBuU + + + _5268608556792470480 mel3l7ZRXwnAEsy0Wfxj_ + + + + _17126222195760917357 muiDYQbmwLxL3PGrwWGeP + + + mnU2hwoI16_nZ7reLKJTr + + + + + + + _17126222195760917357 mCm219F3DHVwNe_CsrCeK + + + + _5268608556792470480 mJTScPpWt8plE9Cz9fDU6 + + + + _12512858585554741740 mRwjoMr_aqph4iL4nu8NS + + + + + + _13303058356268144077 mriCvhMavpfheoLNc0eCD + + mDUyr1RAsHMG7u1BeTW3F + + mhl3Z6oGBbP13ZxehUcg9 + + + + + + mhl3Z6oGBbP13ZxehUcg9 + + + + + + + mLfKYVMLDthbyvvLerNPJ + + _12512858585554741740 mINcNsH05D0QZDej9wl4h + + + + mbYMUxVFybbviIFqRhN2f + + + + mQk9KGg1kmiZQnIZzbOuE + MarkerDetector_Impl myuwTFtkH1L5Be2OVY9rt + + detect mhORIPgMIfN3Fn8aCQBuU + const cv maKLz6mCz5anFyVle_MtD + Mat& _17276638435886805939, vector mYfYoOWdsOLTDCIBT7npX + + Marker m_j6ZkbEfLCgUqtaolYTp + + + & _17726690318409070815, Mat _2920695669964880276, Mat _14932605280544191270, + mOcs0qqtJYmueMnfTyCFx + + _3145974845315888936, mU8SToe5QpPWgY0z9QAcm + _606330642723070475 mzf4ZxeZY8wF2XnrdYK61 + + + mfKhTg3wpiK_YhdQzWWcS + + + + _17726690318409070815.clear mFwk30320retpLBiICndp + mINcNsH05D0QZDej9wl4h + + + + + _8381292230366782771.clear mf_hJsy06Me1epT4PRx_l + + + + mJTScPpWt8plE9Cz9fDU6 + + + + + + + _3822229300092794986.clear mf_hJsy06Me1epT4PRx_l + + + + + + mPdHdcAZ6XJhwf8wLtULI + + + + + mJvv2tbrel2xOYjvgipUL + + + mtbP4KQJdh36UGELfV2zq + + + _17276638435886805939.type mwTQhkbVNQHd2Xw4EA4fj + + + + mZVOYp2JAGvUM7UPbzd3Q + CV_8UC3 mmCJ670wA_VHgip7JZ1dW + + + cv mEMN2sRTwHcTUl7SNSw0d + + + + cvtColor mhORIPgMIfN3Fn8aCQBuU + + + + + +_17276638435886805939,_5695532303110145495,CV_BGR2GRAY muiDYQbmwLxL3PGrwWGeP + + + + + mdmuaUz9iCkCckSUhcEv1 + + mnkTvEdpCXelpIHLLqQno + + _5695532303110145495 mM3tRrWbRPqPOU3G4ShKT + + _17276638435886805939 mriCvhMavpfheoLNc0eCD + + + + + + mYKwa_OYBeVXzRPMa_mz6 + + + + _13068154224003753843 ma6VjqdfajK4BX9gkoGiD + +1 mINcNsH05D0QZDej9wl4h + + + + + cv mEMN2sRTwHcTUl7SNSw0d + + Mat _14658983814685479377 mVOlbMaOu1U0SC2oeKIzP + + + + + + cv maKLz6mCz5anFyVle_MtD + + + + + + Size _17451659640061119372 mdKhcOUXVqyCMdccisL_a + _5695532303110145495.size mdWkXjuaPd4Se0r0SdY1e + + + + mxdAvfSsdzliezc0uyUMk + + + + + myYAiLHDT3JvFKUJCC_FN + _244032483434193613 muQdV4OJL6V6gVxW6AdRy + + _13365150943186347431 mFsSEF_3_iD2mT6nZG9QR + _17276638435886805939.size mwTQhkbVNQHd2Xw4EA4fj + + + + mgkSwnYHQivQIpeAwgr20 + + mJTScPpWt8plE9Cz9fDU6 + + + mwQUfI7G4pBH6IJQiBjmU + + + + mp3H4249LtCVDCYFqQqz4 + + _18062104616271777338.lowResMarkerSize mW1ds9XwNwevT5B2b3j8B + + + _244032483434193613 mzf4ZxeZY8wF2XnrdYK61 + + + + + + mfKhTg3wpiK_YhdQzWWcS + + + _13068154224003753843 muQdV4OJL6V6gVxW6AdRy + + mYKwa_OYBeVXzRPMa_mz6 + + + + mFlVjO0mLpwnCN5a1Quio _18062104616271777338.lowResMarkerSize mlqM0snvYcrWCw2_QjhQi + + + + + + /float mReDuVelSknxaDAoDEmwT _244032483434193613 mgkSwnYHQivQIpeAwgr20 + + + mINcNsH05D0QZDej9wl4h + + mUFzn4yJGA8c9qnEcb9dH + + + + + mhxtTU7dvZHXCTSg8B8rx + + + + + + _13068154224003753843 mYfYoOWdsOLTDCIBT7npX + + 0.9 mmCJ670wA_VHgip7JZ1dW + + + mMRNM5hfPBWFjYCspldu3 + + + + _17451659640061119372.width mRwjoMr_aqph4iL4nu8NS + + + + mnqZGwZqTTi1dekKxujAE + + + + +mSa4WnWih0z4lSo9RYUGU _5695532303110145495.cols mzf4ZxeZY8wF2XnrdYK61 + *_13068154224003753843+0.5 mdmuaUz9iCkCckSUhcEv1 + + + + + + + _17451659640061119372.height mif4ZCBkqdiqSYkR9AD0r + + + maOczvhF_v9OTsK70ZZut + + + + miAECMSxGwjxrcOKk0DII + +_5695532303110145495.rows msubWq7nTVSPilWqmTzkx *_13068154224003753843+0.5 mftnbgRvzOIVyL93HyyWt + + + + + + + mEwOO8zzJcEkF96gfFa1e + + + + + + mFlVjO0mLpwnCN5a1Quio + + _17451659640061119372.width%2 mpi20hzA7RnQ_cRlycwva + + 0 mzf4ZxeZY8wF2XnrdYK61 + + _17451659640061119372.width mi940TUip6nLdi0tWD33F + + mINcNsH05D0QZDej9wl4h + + + + mRzhpvoeHZK7yCqqzYDDp + + mFsSEF_3_iD2mT6nZG9QR + + + + _17451659640061119372.height%2 ma43zKzGwyDT5C3mNdj6s + + + + + + 0 mgkSwnYHQivQIpeAwgr20 + + _17451659640061119372.height mo7mKuzaX2h9vw2rEj5qh + + + + mftnbgRvzOIVyL93HyyWt + + + + + cv mdssZV6TB06aiisDwN1cX + + + + + + resize mhxtTU7dvZHXCTSg8B8rx + + + +_5695532303110145495,_14658983814685479377,_17451659640061119372,0,0,cv mdssZV6TB06aiisDwN1cX + INTER_NEAREST mhyL_M5gnmQzwyHW45MdA + mxdAvfSsdzliezc0uyUMk + + + + mbYMUxVFybbviIFqRhN2f + + + + + mDUyr1RAsHMG7u1BeTW3F + + + mXkfygpbRUCrOfJA4ktlP + _14658983814685479377.empty mbHCSQc_uaLNP9Sf4Lz_n + + + + mycwFs63h7Mi3ggRkMEVm + + + + + + + _14658983814685479377 mM3tRrWbRPqPOU3G4ShKT + + _5695532303110145495 mVOlbMaOu1U0SC2oeKIzP + + + mfySD3GO3N8Vw4agWXnxR + _129190561668282002 mM3tRrWbRPqPOU3G4ShKT + + + + + mRrVhT0WkQauAZEUJHKOK + + mhGXMe8LHJXydR9dMisHj + + + + std mU808frSKQDZnEEU3Q3s9 + + thread _12147666622506655697 mVOlbMaOu1U0SC2oeKIzP + + + mwxm9pz2KjGAhBIIfFMf4 + + + _129190561668282002 mmCJ670wA_VHgip7JZ1dW + + + mN0TszoCQmyzxmobsgV2H + + mJvv2tbrel2xOYjvgipUL + + miAECMSxGwjxrcOKk0DII + + _18062104616271777338.maxThreads mBpPKNB5wfuTOV223BA2r + + 1 mzf4ZxeZY8wF2XnrdYK61 + + _12147666622506655697 myJHqW7fkn_72nVEhKeZ6 + + std mfx1fLYDWN4YRZNnQEsJN + + thread mFlVjO0mLpwnCN5a1Quio + + mY2nz8M_6jpSxQZL8EYgU + & msdqcdg5NNrdQnc_PT1Ee + + mfKhTg3wpiK_YhdQzWWcS + + _11672520815028075718 mFlVjO0mLpwnCN5a1Quio + + _14234691456098337398,_5695532303110145495 ,2*_2048331705952164624 mKpq3GwvJxRduE5RsGgGP + + + + mgkSwnYHQivQIpeAwgr20 + mlqoNTA3LQoUJF6i5YDFc + + mhl3Z6oGBbP13ZxehUcg9 + + + + mgkSwnYHQivQIpeAwgr20 + + + mINcNsH05D0QZDej9wl4h + + + + + + + mUwTrZwI1VfAXDN69k3UA + + + _11672520815028075718 mFlVjO0mLpwnCN5a1Quio + _14234691456098337398,_5695532303110145495,2*_2048331705952164624 mH1xQMRmYb0Y4RDp2hARz + + mzf4ZxeZY8wF2XnrdYK61 + + + mhGXMe8LHJXydR9dMisHj + mgjPImSFwUcUKl9XTKqqB + mUwTrZwI1VfAXDN69k3UA + + mjbtcSgN5ZQfkGDsoYG4l + + _14234691456098337398.resize mtbP4KQJdh36UGELfV2zq + + + + + 1 mmCJ670wA_VHgip7JZ1dW + + + + + + mftnbgRvzOIVyL93HyyWt + _14234691456098337398 mdF98bHO7yrxGJn0aQZVK + 0 mwTp2D1d4PfxNNOzzUfhS + + + + + mRwjoMr_aqph4iL4nu8NS + + + + +_5695532303110145495 mlqoNTA3LQoUJF6i5YDFc + + + mbYMUxVFybbviIFqRhN2f + + + + + + + mdbRZP7cWFYlUcaGRMsKc + + _12394504057001631557 mu_nOcTFwUo8r0uNE351R + + +0 mriCvhMavpfheoLNc0eCD + + mHaUGkpJ3E2hPS8TahoVd + + + + + +_3576709793526977325 mRwjoMr_aqph4iL4nu8NS + + + + mEzFcmvX0IX3FOucgCcVF + + mdmuaUz9iCkCckSUhcEv1 + + + + + std mYGfQUZmV9IjKAPVrLhZl + + + vector mlP1m6taP4mQVYA_j8Oxe + + + + + mWokjWH0MHqyBOx4j0Oac + + + + + + mRHNkLPwUSnx20pmLgrTq + + _3176948232212421105 mReDuVelSknxaDAoDEmwT 256,0 mgkSwnYHQivQIpeAwgr20 + mdmuaUz9iCkCckSUhcEv1 + + do mnU2hwoI16_nZ7reLKJTr + + + + + vector mHkLXuUOlyX2vZI7w3FQj + + + + + MarkerCandidate mel3l7ZRXwnAEsy0Wfxj_ + + _6528263073538749848 mPdHdcAZ6XJhwf8wLtULI + + + _6528263073538749848 mu_nOcTFwUo8r0uNE351R + + + + _11288135742209909849 mReDuVelSknxaDAoDEmwT + _14658983814685479377 mlqM0snvYcrWCw2_QjhQi + mxdAvfSsdzliezc0uyUMk + + + _11052496863352632219 mu_nOcTFwUo8r0uNE351R + + + + + +_16594497104544919971 mNDJrNgMXB1tBoFNaJO0d + + + 0 mbViqhyIcr6lGWibuo3Im + + mhGXMe8LHJXydR9dMisHj + + + + + + + + _6528263073538749848 mRwjoMr_aqph4iL4nu8NS + + _17990657514663812703 mSa4WnWih0z4lSo9RYUGU + + + _6528263073538749848,_14658983814685479377.size mdWkXjuaPd4Se0r0SdY1e + + mhyL_M5gnmQzwyHW45MdA + + + + mhGXMe8LHJXydR9dMisHj + + + + + + + mJvv2tbrel2xOYjvgipUL + + + miAECMSxGwjxrcOKk0DII + + + _12147666622506655697.joinable mbHCSQc_uaLNP9Sf4Lz_n + + + mzf4ZxeZY8wF2XnrdYK61 + + + _12147666622506655697.join mKpq3GwvJxRduE5RsGgGP + mxdAvfSsdzliezc0uyUMk + + + + + + + + + myYAiLHDT3JvFKUJCC_FN + _16638475367102933605 mM3tRrWbRPqPOU3G4ShKT + + + + _2048331705952164624 mf_hJsy06Me1epT4PRx_l + + + + mdmuaUz9iCkCckSUhcEv1 + + + + _17726690318409070815.clear mH1xQMRmYb0Y4RDp2hARz + mVOlbMaOu1U0SC2oeKIzP + + + _3822229300092794986.clear mKpq3GwvJxRduE5RsGgGP + + + + mriCvhMavpfheoLNc0eCD + + + + moPdTa5HpJKbS1U6TqDjY + + + m_6hetAMDOSYN9CmiL4W7 + + + &_13303058356268144200:_3176948232212421105 mycwFs63h7Mi3ggRkMEVm + + + _13303058356268144200 mM3tRrWbRPqPOU3G4ShKT + + 0 mVOlbMaOu1U0SC2oeKIzP + + + + + + + mOcs0qqtJYmueMnfTyCFx + + + + + + _4389716511175480620 mM3tRrWbRPqPOU3G4ShKT + + + std mdssZV6TB06aiisDwN1cX + + + + + +pow mFsSEF_3_iD2mT6nZG9QR + + + static_cast mqEAvVDOCXqrrwrTRByrM + + + + + maOczvhF_v9OTsK70ZZut + + + m_j6ZkbEfLCgUqtaolYTp + + mp3H4249LtCVDCYFqQqz4 + + + + _16638475367102933605 mmCJ670wA_VHgip7JZ1dW + , 2.f mAnDeXfeHaujEzGBbrjil + + + + mlqoNTA3LQoUJF6i5YDFc + + + mtvEQgcnwdOR4zAMwLHDb mReDuVelSknxaDAoDEmwT size_t _13303058356268144138 mKcKHr_bTagXAK_pf8btG + 0 mftnbgRvzOIVyL93HyyWt + + + + + + _13303058356268144138 mbG1GEmOdh2dXkJZ42sXo + + _6528263073538749848.size mH1xQMRmYb0Y4RDp2hARz + + mJTScPpWt8plE9Cz9fDU6 + + _13303058356268144138 mkGHGzUDDVqHIjIdYGe6S + + + mzf4ZxeZY8wF2XnrdYK61 + + + mLdYY4X2b7VOjtTSnd7Hj + + + + + cv mpJt2kGThF7wb3VNzG38b + + Mat _15992684031433922312,_10663945753493258003 mVOlbMaOu1U0SC2oeKIzP + + + + + + cv mpJt2kGThF7wb3VNzG38b + Mat _4885984703856395612 mu_nOcTFwUo8r0uNE351R + _14658983814685479377 mPdHdcAZ6XJhwf8wLtULI + + + + + MarkerCandidate _2464785045917898834 ma6VjqdfajK4BX9gkoGiD _6528263073538749848 mZnfmoDANjVLDjZfzM5MR _13303058356268144138 mJtGCV8zXQjnVDVBVdvFZ + mJTScPpWt8plE9Cz9fDU6 + + mJvv2tbrel2xOYjvgipUL + + miAECMSxGwjxrcOKk0DII + + + _129190561668282002 mhyL_M5gnmQzwyHW45MdA + + mJkMyi0NbVRDgE__LMR_m + + + + + + + + + + size_t _8260498189655844414 mM3tRrWbRPqPOU3G4ShKT + + + 0 mlqoNTA3LQoUJF6i5YDFc + + + + m_owRLEm0gIJ4StPRwTkZ + + + + + mSa4WnWih0z4lSo9RYUGU + size_t _13303058356268144073 mKcKHr_bTagXAK_pf8btG + 1 mxdAvfSsdzliezc0uyUMk + + + + _13303058356268144073 mYfYoOWdsOLTDCIBT7npX _14234691456098337398.size mKpq3GwvJxRduE5RsGgGP + + mhGXMe8LHJXydR9dMisHj + + _13303058356268144073 mEZrtAN7pSZl5y4oEHd38 + + + mgkSwnYHQivQIpeAwgr20 + + + + + + mT_x8cqp5t43PgqNMR8gO + + + mwQUfI7G4pBH6IJQiBjmU + + + miAECMSxGwjxrcOKk0DII + + + + _6528263073538749848 mA4oXllup8K3T5dxkluRR + + _13303058356268144138 mUB1yrSrKOwldqxmCatN2 + + + + + + .getArea mH1xQMRmYb0Y4RDp2hARz + / pow mp3H4249LtCVDCYFqQqz4 + + + 4, _13303058356268144073 msubWq7nTVSPilWqmTzkx + + mij4fDpzx7A1fAEkEKDEN + + + + + + _4389716511175480620 muiDYQbmwLxL3PGrwWGeP + _8260498189655844414 mif4ZCBkqdiqSYkR9AD0r + + + + _13303058356268144073 mINcNsH05D0QZDej9wl4h + + + mFK5JCwqLjSVNjbuFv1Xz + + + + + + mpDI48gcBVmyAktanjCOQ mhGXMe8LHJXydR9dMisHj + + + + mbYMUxVFybbviIFqRhN2f + + + _4885984703856395612 muQdV4OJL6V6gVxW6AdRy + _14234691456098337398 mWkGo8xUdRIKgJ1DEUvvn + _8260498189655844414 mbViqhyIcr6lGWibuo3Im + mdmuaUz9iCkCckSUhcEv1 + + + + + + mnqZGwZqTTi1dekKxujAE + _12315412216670737167 muQdV4OJL6V6gVxW6AdRy + + maISPbNJKXWB2QqsuuExM + + + + mtbP4KQJdh36UGELfV2zq + + + + _4885984703856395612.cols mhyL_M5gnmQzwyHW45MdA + + /float miAECMSxGwjxrcOKk0DII + + + + _14658983814685479377.cols mhyL_M5gnmQzwyHW45MdA + + + + mVOlbMaOu1U0SC2oeKIzP + + + m_owRLEm0gIJ4StPRwTkZ + + + + mhORIPgMIfN3Fn8aCQBuU + auto& _13303058356268144073 : _2464785045917898834 mycwFs63h7Mi3ggRkMEVm _13303058356268144073 mYPzKChOwisp1u2IoCgxk + + + _12315412216670737167 mINcNsH05D0QZDej9wl4h + + + + + mICILgDpdCTDSJqQAn06L + + + + + + + warp mFlVjO0mLpwnCN5a1Quio + + + + _4885984703856395612, _15992684031433922312, Size mp3H4249LtCVDCYFqQqz4 + + _16638475367102933605,_16638475367102933605 mgkSwnYHQivQIpeAwgr20 + + + + + ,_2464785045917898834 msubWq7nTVSPilWqmTzkx mJTScPpWt8plE9Cz9fDU6 + + meWm4MhzbcJwavtoh469w + + + + _16232574195069562653, _2394613391546474355 mriCvhMavpfheoLNc0eCD + + mPBSejyyYBZX7KoLjIvqq + + _5268605234497773616,_5268608555081593998 mVOlbMaOu1U0SC2oeKIzP + + + + cv mpJt2kGThF7wb3VNzG38b + + minMaxIdx mp3H4249LtCVDCYFqQqz4 + + + + _15992684031433922312,&_5268605234497773616,&_5268608555081593998 mzf4ZxeZY8wF2XnrdYK61 + + mlqoNTA3LQoUJF6i5YDFc + + + + + _15992684031433922312.copyTo miAECMSxGwjxrcOKk0DII + + + + _10663945753493258003 mzf4ZxeZY8wF2XnrdYK61 + + mhGXMe8LHJXydR9dMisHj + string _13962554610986522386 mriCvhMavpfheoLNc0eCD + + + + + + + mwQUfI7G4pBH6IJQiBjmU + + + + + + mp3H4249LtCVDCYFqQqz4 + + + _4383831888714590158 mnt0Yxwh2kXjuvEydiY6Z + + + + + +detect mhxtTU7dvZHXCTSg8B8rx + + _10663945753493258003, _16232574195069562653, _2394613391546474355,_13962554610986522386 msubWq7nTVSPilWqmTzkx + + mzf4ZxeZY8wF2XnrdYK61 + + mMRNM5hfPBWFjYCspldu3 + + + + _17726690318409070815.push_back mhxtTU7dvZHXCTSg8B8rx + + + + + + _6528263073538749848 mNDJrNgMXB1tBoFNaJO0d + + + + + _13303058356268144138 mUB1yrSrKOwldqxmCatN2 + + msubWq7nTVSPilWqmTzkx + + + mPdHdcAZ6XJhwf8wLtULI + + _17726690318409070815.back mKpq3GwvJxRduE5RsGgGP + .id ma6VjqdfajK4BX9gkoGiD + _16232574195069562653 mxdAvfSsdzliezc0uyUMk + + + _17726690318409070815.back mbHCSQc_uaLNP9Sf4Lz_n + + + + + + .dict_info mdKhcOUXVqyCMdccisL_a + + _13962554610986522386 mJTScPpWt8plE9Cz9fDU6 + + + _17726690318409070815.back mH1xQMRmYb0Y4RDp2hARz + + .contourPoints muQdV4OJL6V6gVxW6AdRy + + + + + + _6528263073538749848 mNDJrNgMXB1tBoFNaJO0d + + + _13303058356268144138 mbViqhyIcr6lGWibuo3Im + + + + .contourPoints mxdAvfSsdzliezc0uyUMk + + + + + + std mdssZV6TB06aiisDwN1cX + rotate mhxtTU7dvZHXCTSg8B8rx + + + + + + _17726690318409070815.back mKpq3GwvJxRduE5RsGgGP + + + +.begin mH1xQMRmYb0Y4RDp2hARz + + + + + + , + _17726690318409070815.back mcznTYeCGOAygtXXAPYS_ + + + + + +.begin mwTQhkbVNQHd2Xw4EA4fj + + 4 - _2394613391546474355, + _17726690318409070815.back mFwk30320retpLBiICndp + .end mcznTYeCGOAygtXXAPYS_ + + + + + + mzf4ZxeZY8wF2XnrdYK61 + + + mINcNsH05D0QZDej9wl4h + + + mMNJIG0z6TLGgbjrhllmy + + + + + + mp3H4249LtCVDCYFqQqz4 + _18062104616271777338.thresMethod mnZ6t3BhMZ_1d7zzE72ah + + + + MarkerDetector maKLz6mCz5anFyVle_MtD + + + + + + THRES_AUTO_FIXED muiDYQbmwLxL3PGrwWGeP + + + + _6617398332792794799 mtbP4KQJdh36UGELfV2zq + + + + + + _15992684031433922312,_3176948232212421105 mAnDeXfeHaujEzGBbrjil + + + mPdHdcAZ6XJhwf8wLtULI + + + + + mCvAz6nTbqhvwRULRgKe4 + + + mv1ijGQAKacWqWAusY8nc + mfKhTg3wpiK_YhdQzWWcS + + + + + + + _3822229300092794986.push_back mtbP4KQJdh36UGELfV2zq + + + +_6528263073538749848 mY2nz8M_6jpSxQZL8EYgU + + + + + + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + + mgkSwnYHQivQIpeAwgr20 + + + + + + mftnbgRvzOIVyL93HyyWt + + + + + + maCQ9r5fSln_CXgRXGFvO + + + + + + mhl3Z6oGBbP13ZxehUcg9 + + + mEwOO8zzJcEkF96gfFa1e + mhxtTU7dvZHXCTSg8B8rx _17726690318409070815.size maHkatHu0Jap4oTaT5q4_ + + + mYsjCP2nXqW2Jls3JAUkc + + 0 mBJ7M0ikk98KhD4Oi32wB + _18062104616271777338.thresMethod mi0dc2wlXgNoHf9VPli9f + + + + + +MarkerDetector myuwTFtkH1L5Be2OVY9rt + + + + THRES_AUTO_FIXED mBJ7M0ikk98KhD4Oi32wB + + + + mUq8qfNXjDE9FPlMHvjf4 + + + + + + _12394504057001631557 mHkLXuUOlyX2vZI7w3FQj + + + _18062104616271777338.NAttemptsAutoThresFix mycwFs63h7Mi3ggRkMEVm + + + + + + mMRNM5hfPBWFjYCspldu3 + + + _18062104616271777338.ThresHold mdKhcOUXVqyCMdccisL_a + + + + 10+ rand mbHCSQc_uaLNP9Sf4Lz_n + + + + %230 mVOlbMaOu1U0SC2oeKIzP + + + + + + + _3576709793526977325 muQdV4OJL6V6gVxW6AdRy + + + mgor9wB6mrVARR8vJt7rC + + + + mVOlbMaOu1U0SC2oeKIzP + + + + + mICILgDpdCTDSJqQAn06L + + mUwTrZwI1VfAXDN69k3UA + + _3576709793526977325 mKcKHr_bTagXAK_pf8btG + + me9YsE5_K5dlCgWRVtztQ + + mPdHdcAZ6XJhwf8wLtULI + + mbYMUxVFybbviIFqRhN2f + + + + + +while mp3H4249LtCVDCYFqQqz4 + + +_3576709793526977325 mmCJ670wA_VHgip7JZ1dW + + + mxdAvfSsdzliezc0uyUMk + + + + + + + mEwOO8zzJcEkF96gfFa1e + + + + + + mhxtTU7dvZHXCTSg8B8rx + _18062104616271777338.thresMethod mi0dc2wlXgNoHf9VPli9f + + + MarkerDetector mfx1fLYDWN4YRZNnQEsJN + THRES_AUTO_FIXED mycwFs63h7Mi3ggRkMEVm + + mjbtcSgN5ZQfkGDsoYG4l + + + meWm4MhzbcJwavtoh469w + _10168097341276716268 muQdV4OJL6V6gVxW6AdRy + + + + _5695532316837479313 mSa4WnWih0z4lSo9RYUGU + +_3176948232212421105 msubWq7nTVSPilWqmTzkx + + + + mPdHdcAZ6XJhwf8wLtULI + mhGXMe8LHJXydR9dMisHj + + + mXkfygpbRUCrOfJA4ktlP _10168097341276716268 mel3l7ZRXwnAEsy0Wfxj_ + + 0 mXAYJa6osZ6HNTIEEBnr0 + + + + _18062104616271777338.ThresHold mRwjoMr_aqph4iL4nu8NS + + maOczvhF_v9OTsK70ZZut + + mmmC9tOGiLK6UaJr0E5vz + + _10168097341276716268 mzf4ZxeZY8wF2XnrdYK61 + + + + + + mxdAvfSsdzliezc0uyUMk + + + + + mJOnXqKm3GBylSdRjpXAA + + +#ifdef debug_lines + cv mU808frSKQDZnEEU3Q3s9 + imshow miAECMSxGwjxrcOKk0DII + "\x5c\x78\x36\x39\x5c\x78\x36\x64\x5c\x78\x36\x31\x5c\x78\x36\x37\x5c\x78\x36\x35\x5c\x78\x32\x64\x5c\x78\x36\x63\x5c\x78\x36\x39\x5c\x78\x36\x65\x5c\x78\x36\x35\x5c\x78\x37\x33",image mycwFs63h7Mi3ggRkMEVm + + mINcNsH05D0QZDej9wl4h + + + + cv mU808frSKQDZnEEU3Q3s9 + + waitKey mFsSEF_3_iD2mT6nZG9QR + + + 10 muiDYQbmwLxL3PGrwWGeP + + + + + + mJTScPpWt8plE9Cz9fDU6 + +#endif + + mWHxIxEh8g9mg3Hyipn8D + + mReDuVelSknxaDAoDEmwT + + + +_17276638435886805939.cols muOzaq9SXefX6wOasanyX _14658983814685479377.cols mhyL_M5gnmQzwyHW45MdA + + mjbtcSgN5ZQfkGDsoYG4l + + + + + + + _14028278894506040778 mSa4WnWih0z4lSo9RYUGU _17726690318409070815,_14658983814685479377.size mf_hJsy06Me1epT4PRx_l + + + + muiDYQbmwLxL3PGrwWGeP + + + + mhGXMe8LHJXydR9dMisHj + + + mDUyr1RAsHMG7u1BeTW3F + + + + + + + + + + mikiSyOnVry6pvQ1Ds28H + + _18062104616271777338.trackingMinDetections mYxohqgekcJ8HhaDZvWcX + + + 0 msubWq7nTVSPilWqmTzkx + + + + mfKhTg3wpiK_YhdQzWWcS + + + + + + + + + mVRbVdVjFvNmKzGv4WiNp + + + + + m_6hetAMDOSYN9CmiL4W7 + &_16232574195041803256:_10242768842256594623 mXAYJa6osZ6HNTIEEBnr0 + + + + + mJkMyi0NbVRDgE__LMR_m + + + moRHJd8MnQc4OOt6sDvUk + + std mBBHVSlvDGP5NVUfEuhuf + + find mtbP4KQJdh36UGELfV2zq + + _17726690318409070815.begin mdWkXjuaPd4Se0r0SdY1e + +,_17726690318409070815.end mcznTYeCGOAygtXXAPYS_ + + + +,Marker mtbP4KQJdh36UGELfV2zq + + _16232574195041803256.first muiDYQbmwLxL3PGrwWGeP + + + msubWq7nTVSPilWqmTzkx + + + mPlk6hpBhStcHkX9pfoTY _17726690318409070815.end mzeHK1hG1SYQMISNMWMB8 + muiDYQbmwLxL3PGrwWGeP + + + _16232574195041803256.second mif4ZCBkqdiqSYkR9AD0r + + + + std mfx1fLYDWN4YRZNnQEsJN + + max mp3H4249LtCVDCYFqQqz4 + + + + _16232574195041803256.second-1,0 mzf4ZxeZY8wF2XnrdYK61 + + mVOlbMaOu1U0SC2oeKIzP + + + + mnSkEvR4SbDwQxj23xB1M + + + + + + + std mdssZV6TB06aiisDwN1cX + vector mYfYoOWdsOLTDCIBT7npX + +Marker mEc9zv3P8LW8haIvtztwe + + + + + + _2206836681894751447 mJTScPpWt8plE9Cz9fDU6 + + + + + + + ms9iveRK8Fk_QtPMDvDcP + + mvAxy99EwaX0EkXFRf6SN _13303058356268144134:_6872264293741719360 mXAYJa6osZ6HNTIEEBnr0 + + mLdYY4X2b7VOjtTSnd7Hj + + + mX_x9bVx2zqKO8c2FxqgZ std mUCEzhGWrU8OYqcHVPlVW + + + + +find mReDuVelSknxaDAoDEmwT + + _17726690318409070815.begin mbHCSQc_uaLNP9Sf4Lz_n + + + ,_17726690318409070815.end mcznTYeCGOAygtXXAPYS_ + + + + ,Marker mSa4WnWih0z4lSo9RYUGU + + + + + + _13303058356268144134.id muiDYQbmwLxL3PGrwWGeP + + + + mgkSwnYHQivQIpeAwgr20 + + + + maDn6NcmB5JPmBvJglMEd _17726690318409070815.end maHkatHu0Jap4oTaT5q4_ + mlqM0snvYcrWCw2_QjhQi + mT_x8cqp5t43PgqNMR8gO + + mVHGLK1C5RNdKdXzDgMZU + + + + + + _10242768842256594623.count mtbP4KQJdh36UGELfV2zq + + + + + + _13303058356268144134.id mXAYJa6osZ6HNTIEEBnr0 + + + mZk2lUQMDVDhOLQdg9s92 + 0 mycwFs63h7Mi3ggRkMEVm mjbtcSgN5ZQfkGDsoYG4l + + + + + + + mBuRRlPSkgfIqW4MkJEkn + + _10242768842256594623.at mp3H4249LtCVDCYFqQqz4 _13303058356268144134.id mhyL_M5gnmQzwyHW45MdA + + + + moE42zHNBVjnlCdllZAkS + + + _18062104616271777338.trackingMinDetections mmCJ670wA_VHgip7JZ1dW + + + + + _2206836681894751447.push_back mSa4WnWih0z4lSo9RYUGU + + + + + + _13303058356268144134 mhyL_M5gnmQzwyHW45MdA + + + + mxdAvfSsdzliezc0uyUMk + mnSkEvR4SbDwQxj23xB1M + + + + + + + mhl3Z6oGBbP13ZxehUcg9 + + + mnSkEvR4SbDwQxj23xB1M + + + + + + mX_x9bVx2zqKO8c2FxqgZ + + + + + + _2206836681894751447.size mcznTYeCGOAygtXXAPYS_ + + + + + mEc9zv3P8LW8haIvtztwe + + 0 mlqM0snvYcrWCw2_QjhQi + + + + mN0TszoCQmyzxmobsgV2H + + mmB6x9VkGrq_qpFtMKL7A + + _16807308463767004315 mnU2hwoI16_nZ7reLKJTr + + + _16807308463767004315 mSa4WnWih0z4lSo9RYUGU + + + +const Marker &_13303058356268144134 msubWq7nTVSPilWqmTzkx + + mLdYY4X2b7VOjtTSnd7Hj + + _12469364278809815631._2329825236964917351 mSa4WnWih0z4lSo9RYUGU + + + _13303058356268144134 mXAYJa6osZ6HNTIEEBnr0 + mriCvhMavpfheoLNc0eCD + + + + muuG2jhk4iNsA9KNmj6oA + + _4191776636076832364 _12469364278809815631 mdmuaUz9iCkCckSUhcEv1 + + + + + + + mCujczJix6jMpJcynoBiA + _3412165392495317931 mKcKHr_bTagXAK_pf8btG + + + + + + -1 mINcNsH05D0QZDej9wl4h + + + mvfKgFvXHh0Jqv_PZxbka + + + + _17998515892213527232 myJHqW7fkn_72nVEhKeZ6 std mpJt2kGThF7wb3VNzG38b numeric_limits mYfYoOWdsOLTDCIBT7npX + + mPBSejyyYBZX7KoLjIvqq + + + + mel3l7ZRXwnAEsy0Wfxj_ + + mBBHVSlvDGP5NVUfEuhuf + + + + max mFwk30320retpLBiICndp + mriCvhMavpfheoLNc0eCD + + + mDUyr1RAsHMG7u1BeTW3F + mJTScPpWt8plE9Cz9fDU6 + + std mYGfQUZmV9IjKAPVrLhZl + + + + + + map mYfYoOWdsOLTDCIBT7npX + + + + int,_16807308463767004315 m_j6ZkbEfLCgUqtaolYTp + + _5298924430305139424 mdmuaUz9iCkCckSUhcEv1 + + + mVRbVdVjFvNmKzGv4WiNp + mgxs4jaOm5WhsuDH7hsbo + + &_5268605234514274795:_2206836681894751447 muiDYQbmwLxL3PGrwWGeP + + _5298924430305139424.insert mhxtTU7dvZHXCTSg8B8rx + + + + mJkMyi0NbVRDgE__LMR_m _5268605234514274795.id,_16807308463767004315 mFsSEF_3_iD2mT6nZG9QR + _5268605234514274795 msubWq7nTVSPilWqmTzkx + + + + muuG2jhk4iNsA9KNmj6oA + + + muiDYQbmwLxL3PGrwWGeP + + + mftnbgRvzOIVyL93HyyWt + + + ma9rnYFEs_TUiw_WyBflg + + + + + + size_t _3175967376861678913 mM3tRrWbRPqPOU3G4ShKT + 0 mINcNsH05D0QZDej9wl4h + + + + + + _3175967376861678913 mqEAvVDOCXqrrwrTRByrM + _3822229300092794986.size mbHCSQc_uaLNP9Sf4Lz_n + mVOlbMaOu1U0SC2oeKIzP +_3175967376861678913 mkGHGzUDDVqHIjIdYGe6S + + + + + + mycwFs63h7Mi3ggRkMEVm + + + + + + mypSy3lS4LRIjRYTxVxzg + + + + + moNuUrvhPRwgFBZS8fSa1 + &_3176948352186414039 mif4ZCBkqdiqSYkR9AD0r + + _3822229300092794986 mFyKKLtdivGGDlk8sYzsf + + + + + + _3175967376861678913 mrpQVzv6u8gxvho1qUlil + + + mdmuaUz9iCkCckSUhcEv1 + + _4191776636076832364 _4970544023979479897 mlqoNTA3LQoUJF6i5YDFc + _4970544023979479897._2329825236964917351 mFsSEF_3_iD2mT6nZG9QR + + _3176948352186414039 mXAYJa6osZ6HNTIEEBnr0 + + + + mJTScPpWt8plE9Cz9fDU6 + + + + ms9iveRK8Fk_QtPMDvDcP + + + + mZHJfF8VODcHrGq0YEwM_ + + + +&_5268605234514277940:_5298924430305139424 msubWq7nTVSPilWqmTzkx + mfKhTg3wpiK_YhdQzWWcS + + + + + + + mVHGLK1C5RNdKdXzDgMZU + + + _5268605234514277940.second._12469364278809815631._14033480569961022451 mp3H4249LtCVDCYFqQqz4 + + _4970544023979479897._2320218127778479373 mzeHK1hG1SYQMISNMWMB8 + + + mXAYJa6osZ6HNTIEEBnr0 + + + + + + mzf4ZxeZY8wF2XnrdYK61 + + + + mnU2hwoI16_nZ7reLKJTr + + + + mvAxy99EwaX0EkXFRf6SN + _3176008349054602175 ma6VjqdfajK4BX9gkoGiD + + + + cv mUCEzhGWrU8OYqcHVPlVW + + norm mtbP4KQJdh36UGELfV2zq + + + + _5268605234514277940.second._12469364278809815631._2320218127778479373 mH1xQMRmYb0Y4RDp2hARz + -_4970544023979479897._2320218127778479373 mf_hJsy06Me1epT4PRx_l + + mmCJ670wA_VHgip7JZ1dW + + + + mftnbgRvzOIVyL93HyyWt + + + + + m_6hetAMDOSYN9CmiL4W7 + + + _6783445603442262432 myJHqW7fkn_72nVEhKeZ6 + + + + + + fabs mFsSEF_3_iD2mT6nZG9QR + _5268605234514277940.second._12469364278809815631._2462547792112398716 mH1xQMRmYb0Y4RDp2hARz -_4970544023979479897._2462547792112398716 mdWkXjuaPd4Se0r0SdY1e + muiDYQbmwLxL3PGrwWGeP + + /_5268605234514277940.second._12469364278809815631._2462547792112398716 mf_hJsy06Me1epT4PRx_l + mINcNsH05D0QZDej9wl4h + + + + + mikiSyOnVry6pvQ1Ds28H + + _6783445603442262432 mca1GaR7Rv9qOZsisqKBB + 0.3f mKdH1o6rFuMJ1Fl0PA_sn + + _3176008349054602175 mlP1m6taP4mQVYA_j8Oxe + + + _5268605234514277940.second._17998515892213527232 muiDYQbmwLxL3PGrwWGeP + + mN0TszoCQmyzxmobsgV2H + + + + _5268605234514277940.second._3412165392495317931 mM3tRrWbRPqPOU3G4ShKT static_cast mbG1GEmOdh2dXkJZ42sXo + + + + + + mdEzmAkZNQkKD1HrLnSSo + + + + + mjxPa00ei9qkuuQmiGB3C + + mReDuVelSknxaDAoDEmwT + + + _3175967376861678913 msubWq7nTVSPilWqmTzkx + + mxdAvfSsdzliezc0uyUMk + + + _5268605234514277940.second._17998515892213527232 mu_nOcTFwUo8r0uNE351R + + + + +_3176008349054602175 mftnbgRvzOIVyL93HyyWt + + + + mCvAz6nTbqhvwRULRgKe4 + + + + + mbYMUxVFybbviIFqRhN2f + + + + muuG2jhk4iNsA9KNmj6oA + + + mDUyr1RAsHMG7u1BeTW3F + + + + + + miGFoFUQX5urgUZ1Rewwt + + mHXoMWKZSiZYUvqmVkLF5 + + + + +&_5268605234514277940:_5298924430305139424 mXAYJa6osZ6HNTIEEBnr0 + + mDzQQrEx5Ki0C6uDHU2cy + + moRHJd8MnQc4OOt6sDvUk + + _5268605234514277940.second._3412165392495317931 mRuVXNtG32xpaNLi1hDLk + + + + -1 mXAYJa6osZ6HNTIEEBnr0 + continue mxdAvfSsdzliezc0uyUMk + + mgxs4jaOm5WhsuDH7hsbo + + _16232574195069562600 ma6VjqdfajK4BX9gkoGiD + + + + + + find miAECMSxGwjxrcOKk0DII + + _6872264293741719360.begin maHkatHu0Jap4oTaT5q4_ + + + + + + ,_6872264293741719360.end mdWkXjuaPd4Se0r0SdY1e + ,Marker mFlVjO0mLpwnCN5a1Quio + + + + + + _5268605234514277940.first mlqM0snvYcrWCw2_QjhQi msubWq7nTVSPilWqmTzkx + + mlqoNTA3LQoUJF6i5YDFc + _17726690318409070815.push_back mmmC9tOGiLK6UaJr0E5vz + + + _3822229300092794986 mFyKKLtdivGGDlk8sYzsf + + _5268605234514277940.second._3412165392495317931 mUB1yrSrKOwldqxmCatN2 + + + + msubWq7nTVSPilWqmTzkx + + mJTScPpWt8plE9Cz9fDU6 + + + _17726690318409070815.back mbHCSQc_uaLNP9Sf4Lz_n + + .id mRwjoMr_aqph4iL4nu8NS + + _5268605234514277940.first mftnbgRvzOIVyL93HyyWt + + + + _17726690318409070815.back mH1xQMRmYb0Y4RDp2hARz + .dict_info mif4ZCBkqdiqSYkR9AD0r + _16232574195069562600 mwBOm3LXJ8FMsqTgQKZ6O + + + + + + dict_info mVOlbMaOu1U0SC2oeKIzP + + + + + + + _17726690318409070815.back mdWkXjuaPd4Se0r0SdY1e + .contourPoints mRwjoMr_aqph4iL4nu8NS +_3822229300092794986 mZnfmoDANjVLDjZfzM5MR + _5268605234514277940.second._3412165392495317931 mIkhxhgSNMt_JUZR7ce1U + + .contourPoints mriCvhMavpfheoLNc0eCD + + + + + mvAxy99EwaX0EkXFRf6SN + + + _4599602050392954662 mM3tRrWbRPqPOU3G4ShKT + mZnfmoDANjVLDjZfzM5MR mbViqhyIcr6lGWibuo3Im + + + + + + mhxtTU7dvZHXCTSg8B8rx + const vector mHkLXuUOlyX2vZI7w3FQj + + + +cv mBBHVSlvDGP5NVUfEuhuf + + Point2f mEc9zv3P8LW8haIvtztwe + + &_16232574195068577669,const vector mK5OxIt23gZzSiTA8trU8 + + + + + + cv mU808frSKQDZnEEU3Q3s9 + + + Point2f mEc9zv3P8LW8haIvtztwe + + + + + + &_16232574195068577668 mAnDeXfeHaujEzGBbrjil + + mDzQQrEx5Ki0C6uDHU2cy + + cv mdssZV6TB06aiisDwN1cX + + Point2f _14899514829569383848 muQdV4OJL6V6gVxW6AdRy + + _16232574195068577669 mY2nz8M_6jpSxQZL8EYgU + + + + + 1 mDd5IIsnjfLI1lcygRsW3 + -_16232574195068577669 mY2nz8M_6jpSxQZL8EYgU + + 0 msdqcdg5NNrdQnc_PT1Ee + + mriCvhMavpfheoLNc0eCD + + + + + + + _14899514829569383848 mt6CTIKlbWyEq7tYJENOL + + + + 1./cv mUCEzhGWrU8OYqcHVPlVW + + norm mp3H4249LtCVDCYFqQqz4 + + + + +_14899514829569383848 muiDYQbmwLxL3PGrwWGeP + mVOlbMaOu1U0SC2oeKIzP + + + + + cv mBBHVSlvDGP5NVUfEuhuf Point2f _14899514829569383863 mdKhcOUXVqyCMdccisL_a + + + + + + _16232574195068577668 mY2nz8M_6jpSxQZL8EYgU + + + 1 mbViqhyIcr6lGWibuo3Im + + + + -_16232574195068577668 mY2nz8M_6jpSxQZL8EYgU + + + + +0 mbViqhyIcr6lGWibuo3Im + mJTScPpWt8plE9Cz9fDU6 + + + _14899514829569383863 mtBaSZn4xtaMpMhvfebM_ + + + 1./cv mYGfQUZmV9IjKAPVrLhZl + + + + norm miAECMSxGwjxrcOKk0DII + _14899514829569383863 mgkSwnYHQivQIpeAwgr20 + + mxdAvfSsdzliezc0uyUMk + + + mfFGohhJTv_x4m7UMdlWF + + + + + + _14899514829569383848.dot mp3H4249LtCVDCYFqQqz4 _14899514829569383863 mzf4ZxeZY8wF2XnrdYK61 + + mINcNsH05D0QZDej9wl4h + + + muuG2jhk4iNsA9KNmj6oA + mJTScPpWt8plE9Cz9fDU6 + + + + mjc_6rRmys9smvg_opA48 + + + + + + _3257892023090136996 myJHqW7fkn_72nVEhKeZ6 + + + + find mtbP4KQJdh36UGELfV2zq _6872264293741719360.begin mH1xQMRmYb0Y4RDp2hARz + + ,_6872264293741719360.end mbHCSQc_uaLNP9Sf4Lz_n ,Marker mmmC9tOGiLK6UaJr0E5vz +_5268605234514277940.first mgkSwnYHQivQIpeAwgr20 + + + + mycwFs63h7Mi3ggRkMEVm + + + + mlqoNTA3LQoUJF6i5YDFc + pair mK5OxIt23gZzSiTA8trU8 int, mVPyhnVeODFpKcj5PAnUM + + + + + +mel3l7ZRXwnAEsy0Wfxj_ + + _9244962205788679909 mp3H4249LtCVDCYFqQqz4 + + -1,-1 msubWq7nTVSPilWqmTzkx + + + + + mhGXMe8LHJXydR9dMisHj + + + + + + + ms9iveRK8Fk_QtPMDvDcP + + + + mdEzmAkZNQkKD1HrLnSSo + +_13303058356268144075 mdKhcOUXVqyCMdccisL_a + + + 0 mINcNsH05D0QZDej9wl4h + + + _13303058356268144075 mK5OxIt23gZzSiTA8trU8 + + + + + + 4 mriCvhMavpfheoLNc0eCD + + + + + _13303058356268144075 mwwJvnj2j3yLmklxxOEJQ + mlqM0snvYcrWCw2_QjhQi + + + mLdYY4X2b7VOjtTSnd7Hj + + + + + + + vector mW1ds9XwNwevT5B2b3j8B + + cv mEMN2sRTwHcTUl7SNSw0d + + + + +Point2f mRHNkLPwUSnx20pmLgrTq + _5268608437323523861 muQdV4OJL6V6gVxW6AdRy + + _17726690318409070815.back mzeHK1hG1SYQMISNMWMB8 + + + mINcNsH05D0QZDej9wl4h + + + std myuwTFtkH1L5Be2OVY9rt + + rotate mhORIPgMIfN3Fn8aCQBuU + + + + _5268608437323523861 .begin mwTQhkbVNQHd2Xw4EA4fj + + , + _5268608437323523861 .begin maHkatHu0Jap4oTaT5q4_ + + _13303058356268144075, + _5268608437323523861 .end mzeHK1hG1SYQMISNMWMB8 + mgkSwnYHQivQIpeAwgr20 + + + mJTScPpWt8plE9Cz9fDU6 + + + mgxs4jaOm5WhsuDH7hsbo + + _5268611907568609837 mCm219F3DHVwNe_CsrCeK + + _4599602050392954662 mSa4WnWih0z4lSo9RYUGU + + *_3257892023090136996,_5268608437323523861 mgkSwnYHQivQIpeAwgr20 + + + mriCvhMavpfheoLNc0eCD + + + + mX_x9bVx2zqKO8c2FxqgZ + + _5268611907568609837 mYxohqgekcJ8HhaDZvWcX + _9244962205788679909.second mXAYJa6osZ6HNTIEEBnr0 + + + mN0TszoCQmyzxmobsgV2H + + + + _9244962205788679909 mif4ZCBkqdiqSYkR9AD0r + + + + + mfKhTg3wpiK_YhdQzWWcS + + _13303058356268144075,_5268611907568609837 mICILgDpdCTDSJqQAn06L + mINcNsH05D0QZDej9wl4h + + + + + + + mgjPImSFwUcUKl9XTKqqB + + + + maCQ9r5fSln_CXgRXGFvO + + + + + std mYGfQUZmV9IjKAPVrLhZl + + + + + +rotate mmmC9tOGiLK6UaJr0E5vz + + + + _17726690318409070815.back mwTQhkbVNQHd2Xw4EA4fj + + .begin mf_hJsy06Me1epT4PRx_l + + + , + _17726690318409070815.back mcznTYeCGOAygtXXAPYS_ .begin mFwk30320retpLBiICndp + + + _9244962205788679909.first, + _17726690318409070815.back mdWkXjuaPd4Se0r0SdY1e + .end mKpq3GwvJxRduE5RsGgGP mhyL_M5gnmQzwyHW45MdA + + + + mftnbgRvzOIVyL93HyyWt + + + + _3822229300092794986 mILaQGKCAmcKrYQNhgWUq + + _5268605234514277940.second._3412165392495317931 mEFd2D2UDF9SIoPfQtUv6 + + + .clear maHkatHu0Jap4oTaT5q4_ + + mPdHdcAZ6XJhwf8wLtULI + + muuG2jhk4iNsA9KNmj6oA + + + + + + + + _3822229300092794986.erase miAECMSxGwjxrcOKk0DII +std mpJt2kGThF7wb3VNzG38b + + + remove_if mhORIPgMIfN3Fn8aCQBuU + _3822229300092794986.begin mdWkXjuaPd4Se0r0SdY1e + + + + ,_3822229300092794986.end maHkatHu0Jap4oTaT5q4_ + + + , mZnfmoDANjVLDjZfzM5MR mrpQVzv6u8gxvho1qUlil + + + + mSa4WnWih0z4lSo9RYUGU const vector mK5OxIt23gZzSiTA8trU8 + + + + cv mYGfQUZmV9IjKAPVrLhZl Point2f mEc9zv3P8LW8haIvtztwe &_13303058356268144134 mmCJ670wA_VHgip7JZ1dW + + + + + mfKhTg3wpiK_YhdQzWWcS + + mLfKYVMLDthbyvvLerNPJ + + + _13303058356268144134.size mzeHK1hG1SYQMISNMWMB8 + mgAgf2KiVOzOHJDU4qKPI +0 mPdHdcAZ6XJhwf8wLtULI + + + mICILgDpdCTDSJqQAn06L + + + + mlqM0snvYcrWCw2_QjhQi + + + + + + , _3822229300092794986.end mcznTYeCGOAygtXXAPYS_ mAnDeXfeHaujEzGBbrjil mlqoNTA3LQoUJF6i5YDFc + + + + + + mgjPImSFwUcUKl9XTKqqB + + ms9iveRK8Fk_QtPMDvDcP + + + + mgxs4jaOm5WhsuDH7hsbo + + + _13303058356268144134:_17726690318409070815 mlqM0snvYcrWCw2_QjhQi + + mLdYY4X2b7VOjtTSnd7Hj + + + + + mwxm9pz2KjGAhBIIfFMf4 + + + _10242768842256594623.count mmmC9tOGiLK6UaJr0E5vz + + _13303058356268144134.id mzf4ZxeZY8wF2XnrdYK61 + + mHOvg7vOJH6ujsVsg3S5G + 0 mXAYJa6osZ6HNTIEEBnr0 + + + + + _10242768842256594623 mZnfmoDANjVLDjZfzM5MR + + + + _13303058356268144134.id msdqcdg5NNrdQnc_PT1Ee + ma6VjqdfajK4BX9gkoGiD + + 1 mJTScPpWt8plE9Cz9fDU6 + + + + + + + moT0JKxDJVSALTDfSRUYM + + + + _10242768842256594623 mWkGo8xUdRIKgJ1DEUvvn + + + + + +_13303058356268144134.id mJtGCV8zXQjnVDVBVdvFZ + + + + mkGHGzUDDVqHIjIdYGe6S + mftnbgRvzOIVyL93HyyWt + + + + mJOnXqKm3GBylSdRjpXAA + + + + mhl3Z6oGBbP13ZxehUcg9 + + + + + + + + + mBuRRlPSkgfIqW4MkJEkn + + + + + + 1 mhyL_M5gnmQzwyHW45MdA + + mN0TszoCQmyzxmobsgV2H + + + + + std mYGfQUZmV9IjKAPVrLhZl + + + + + + sort mhORIPgMIfN3Fn8aCQBuU + + _17726690318409070815.begin mcznTYeCGOAygtXXAPYS_ + + + , _17726690318409070815.end mdWkXjuaPd4Se0r0SdY1e + + + + + + mzf4ZxeZY8wF2XnrdYK61 + + + + + + mriCvhMavpfheoLNc0eCD + + + + + vector mYI2nkSxgJHf1pY1PttV1 + mm9xpbYUQ152i_zNBGUZu + + + + + mel3l7ZRXwnAEsy0Wfxj_ + + + + + + _7127668893958858208 miAECMSxGwjxrcOKk0DII + + _17726690318409070815.size mFwk30320retpLBiICndp , mHbmZNNhradVwUtDZ5U7B + + mmCJ670wA_VHgip7JZ1dW + mriCvhMavpfheoLNc0eCD + + + mLBxgVrVeq7bTUcDGJqNH + mFlVjO0mLpwnCN5a1Quio + + moI11mwtxiOXpqDxK_aQL + + + + + + _13303058356268144138 mu_nOcTFwUo8r0uNE351R + + + + 0 mlqoNTA3LQoUJF6i5YDFc + + + + _13303058356268144138 mCALzjQ0bwpDnngl_oSsi + mG7mr0Iq8BCEeADSwrCoW + + mFlVjO0mLpwnCN5a1Quio + + + + _17726690318409070815.size mFwk30320retpLBiICndp mzf4ZxeZY8wF2XnrdYK61 + + - 1 mJTScPpWt8plE9Cz9fDU6 + + _13303058356268144138 mUq8qfNXjDE9FPlMHvjf4 + mgkSwnYHQivQIpeAwgr20 + + mJkMyi0NbVRDgE__LMR_m + + + mtvEQgcnwdOR4zAMwLHDb + mmmC9tOGiLK6UaJr0E5vz + mMGij61UZUIIYyztVz9vN + + + + _13303058356268144139 mKcKHr_bTagXAK_pf8btG + + _13303058356268144138 + 1 mxdAvfSsdzliezc0uyUMk + + + _13303058356268144139 mqEAvVDOCXqrrwrTRByrM + + + + mdEzmAkZNQkKD1HrLnSSo + + miAECMSxGwjxrcOKk0DII + + + + _17726690318409070815.size mwTQhkbVNQHd2Xw4EA4fj + + mhyL_M5gnmQzwyHW45MdA + mOR5gj7K3yTraJVOrvmKy + + + + msFQPbyubcQTkvTYpFFPL + + _7127668893958858208 mY2nz8M_6jpSxQZL8EYgU + _13303058356268144138 mDd5IIsnjfLI1lcygRsW3 + + mJTScPpWt8plE9Cz9fDU6 + + + _13303058356268144139 mBh4lc09qKYGXyU7FeqOv + + + muiDYQbmwLxL3PGrwWGeP + mLdYY4X2b7VOjtTSnd7Hj + + + mvw_MKiY3S1FcVNfJQCRT + miAECMSxGwjxrcOKk0DII + _17726690318409070815 mNDJrNgMXB1tBoFNaJO0d + + + + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + + + + .id maDn6NcmB5JPmBvJglMEd + + + + + + _17726690318409070815 mWkGo8xUdRIKgJ1DEUvvn + _13303058356268144139 mwTp2D1d4PfxNNOzzUfhS + .id mKdH1o6rFuMJ1Fl0PA_sn + + + + _17726690318409070815 mA4oXllup8K3T5dxkluRR _13303058356268144138 mEFd2D2UDF9SIoPfQtUv6 + + + .dict_info mtPtbM6hNfOIkqlx661ci + + _17726690318409070815 mTjppsgNpY1Pjyv5Z_zMr + + + + + _13303058356268144139 mUB1yrSrKOwldqxmCatN2 + + + + .dict_info mAnDeXfeHaujEzGBbrjil + mLdYY4X2b7VOjtTSnd7Hj + + + + mEwOO8zzJcEkF96gfFa1e + mReDuVelSknxaDAoDEmwT + + + + _16109434691388891984 mtbP4KQJdh36UGELfV2zq + + + +_17726690318409070815 mGYpOkNIG_qSvYXBOU9Vf + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + mlqM0snvYcrWCw2_QjhQi mHkLXuUOlyX2vZI7w3FQj + _16109434691388891984 mhORIPgMIfN3Fn8aCQBuU + + + + _17726690318409070815 mNDJrNgMXB1tBoFNaJO0d + +_13303058356268144139 mEFd2D2UDF9SIoPfQtUv6 msubWq7nTVSPilWqmTzkx mXAYJa6osZ6HNTIEEBnr0 + + _7127668893958858208 mTjppsgNpY1Pjyv5Z_zMr + + + + + +_13303058356268144138 mrpQVzv6u8gxvho1qUlil + + + + + + muQdV4OJL6V6gVxW6AdRy + + mgor9wB6mrVARR8vJt7rC + + mJTScPpWt8plE9Cz9fDU6 + + + + + + + else + _7127668893958858208 mZnfmoDANjVLDjZfzM5MR _13303058356268144139 mUB1yrSrKOwldqxmCatN2 + + myJHqW7fkn_72nVEhKeZ6 + + mrYTPN06XEG4I2Q8GwVal + mriCvhMavpfheoLNc0eCD + + + + mICILgDpdCTDSJqQAn06L + + + + + + mICILgDpdCTDSJqQAn06L + + + + + + + mJOnXqKm3GBylSdRjpXAA + + + _17229649132943359639 mReDuVelSknxaDAoDEmwT + + + + _17726690318409070815,_7127668893958858208 mhyL_M5gnmQzwyHW45MdA + + mxdAvfSsdzliezc0uyUMk + + + + + + mJOnXqKm3GBylSdRjpXAA + + + + + + + + + mwQUfI7G4pBH6IJQiBjmU + mtbP4KQJdh36UGELfV2zq + + + _17726690318409070815.size mwTQhkbVNQHd2Xw4EA4fj + + + + + + mW1YUos9eL_9NmgJuSDH7 + + + + + + 0 moejXze8_C6TCxb2bIzgq + + + _17276638435886805939.size mf_hJsy06Me1epT4PRx_l + mPlk6hpBhStcHkX9pfoTY + + + + + _14658983814685479377.size maHkatHu0Jap4oTaT5q4_ + + + + msubWq7nTVSPilWqmTzkx + + mjbtcSgN5ZQfkGDsoYG4l + + + mvw_MKiY3S1FcVNfJQCRT + + + + + + mhxtTU7dvZHXCTSg8B8rx + + + + _18062104616271777338.cornerRefinementM maDn6NcmB5JPmBvJglMEd CORNER_SUBPIX muiDYQbmwLxL3PGrwWGeP mnU2hwoI16_nZ7reLKJTr + + + + + + mSD7jHYN8mOif4_CBtIg6 + + _134566848691226369 mCm219F3DHVwNe_CsrCeK + + 4*float mSa4WnWih0z4lSo9RYUGU + + +_17276638435886805939.cols mzf4ZxeZY8wF2XnrdYK61 + + /float mmmC9tOGiLK6UaJr0E5vz + + _14658983814685479377.cols mlqM0snvYcrWCw2_QjhQi + + + +0.5 mPdHdcAZ6XJhwf8wLtULI + + + + + vector mqEAvVDOCXqrrwrTRByrM + + Point2f mjxPa00ei9qkuuQmiGB3C + _13861179168205423140 mlqoNTA3LQoUJF6i5YDFc + + + mNMDyj9J1Nt8auTKwp8ze + mFsSEF_3_iD2mT6nZG9QR + + unsigned moI11mwtxiOXpqDxK_aQL + + _13303058356268144138 mif4ZCBkqdiqSYkR9AD0r + 0 mJTScPpWt8plE9Cz9fDU6 _13303058356268144138 mbG1GEmOdh2dXkJZ42sXo + _17726690318409070815.size mzeHK1hG1SYQMISNMWMB8 + + + mdmuaUz9iCkCckSUhcEv1 + + + + _13303058356268144138 mo7mKuzaX2h9vw2rEj5qh mXAYJa6osZ6HNTIEEBnr0 + + + + mwzVPTpaJAiRC6bZKMfQX + + mmmC9tOGiLK6UaJr0E5vz + moI11mwtxiOXpqDxK_aQL + + + _13303058356268144199 mu_nOcTFwUo8r0uNE351R + + + + 0 mxdAvfSsdzliezc0uyUMk + + + + _13303058356268144199 mca1GaR7Rv9qOZsisqKBB + + + 4 mlqoNTA3LQoUJF6i5YDFc _13303058356268144199 mBh4lc09qKYGXyU7FeqOv + + mhyL_M5gnmQzwyHW45MdA + + + _13861179168205423140.push_back mFsSEF_3_iD2mT6nZG9QR + + _17726690318409070815 mY2nz8M_6jpSxQZL8EYgU +_13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + mWkGo8xUdRIKgJ1DEUvvn + _13303058356268144199 mJtGCV8zXQjnVDVBVdvFZ mgkSwnYHQivQIpeAwgr20 + + + mlqoNTA3LQoUJF6i5YDFc + + + cornerSubPix mmmC9tOGiLK6UaJr0E5vz + + + + + + _5695532303110145495, _13861179168205423140, cv maKLz6mCz5anFyVle_MtD + Size mhxtTU7dvZHXCTSg8B8rx + + +_134566848691226369,_134566848691226369 mhyL_M5gnmQzwyHW45MdA + + + +, cv mYGfQUZmV9IjKAPVrLhZl + + + Size mhxtTU7dvZHXCTSg8B8rx + -1, -1 mlqM0snvYcrWCw2_QjhQi + ,cv mU808frSKQDZnEEU3Q3s9 + + + + TermCriteria mFsSEF_3_iD2mT6nZG9QR + + + + cv myuwTFtkH1L5Be2OVY9rt + + +TermCriteria mYGfQUZmV9IjKAPVrLhZl + MAX_ITER | cv mpJt2kGThF7wb3VNzG38b + TermCriteria maKLz6mCz5anFyVle_MtD + + + + + + EPS, 12, 0.005 mhyL_M5gnmQzwyHW45MdA + + + + msubWq7nTVSPilWqmTzkx + + mftnbgRvzOIVyL93HyyWt + + + mtvEQgcnwdOR4zAMwLHDb + mp3H4249LtCVDCYFqQqz4 + + unsigned mdbRZP7cWFYlUcaGRMsKc + _13303058356268144138 muQdV4OJL6V6gVxW6AdRy + 0 mJTScPpWt8plE9Cz9fDU6 + + + + + + _13303058356268144138 mCALzjQ0bwpDnngl_oSsi + + + _17726690318409070815.size mFwk30320retpLBiICndp + + mdmuaUz9iCkCckSUhcEv1 _13303058356268144138 mo7mKuzaX2h9vw2rEj5qh + + mycwFs63h7Mi3ggRkMEVm + + + + mHIh6WyQKJh1ZKme1nslP + + + mhORIPgMIfN3Fn8aCQBuU + + + + mMGij61UZUIIYyztVz9vN + + _13303058356268144199 mM3tRrWbRPqPOU3G4ShKT + + + + + + 0 mlqoNTA3LQoUJF6i5YDFc + + _13303058356268144199 mK5OxIt23gZzSiTA8trU8 + + + + 4 mriCvhMavpfheoLNc0eCD + + + _13303058356268144199 mt0bWs8kxCzTnBdtR9vKu + + msubWq7nTVSPilWqmTzkx + + + + _17726690318409070815 mA4oXllup8K3T5dxkluRR + + + _13303058356268144138 mDd5IIsnjfLI1lcygRsW3 + + + mFyKKLtdivGGDlk8sYzsf + + + + _13303058356268144199 mwTp2D1d4PfxNNOzzUfhS + + + + mCm219F3DHVwNe_CsrCeK + + _13861179168205423140 mTjppsgNpY1Pjyv5Z_zMr + + + _13303058356268144138 * 4 + _13303058356268144199 mbViqhyIcr6lGWibuo3Im + + mINcNsH05D0QZDej9wl4h + + + + mgjPImSFwUcUKl9XTKqqB + mFK5JCwqLjSVNjbuFv1Xz + mWHxIxEh8g9mg3Hyipn8D + + + + + + mhxtTU7dvZHXCTSg8B8rx + _18062104616271777338.cornerRefinementM mtPtbM6hNfOIkqlx661ci + + + + + CORNER_LINES mAnDeXfeHaujEzGBbrjil + + + mfKhTg3wpiK_YhdQzWWcS + + + + + + mNMDyj9J1Nt8auTKwp8ze + + + mhxtTU7dvZHXCTSg8B8rx + + unsigned mMGij61UZUIIYyztVz9vN + + _13303058356268144138 mM3tRrWbRPqPOU3G4ShKT + + + 0 mhGXMe8LHJXydR9dMisHj + + _13303058356268144138 mlP1m6taP4mQVYA_j8Oxe + + + + + + _17726690318409070815.size mFwk30320retpLBiICndp + + + mlqoNTA3LQoUJF6i5YDFc + + + _13303058356268144138 mi940TUip6nLdi0tWD33F mhyL_M5gnmQzwyHW45MdA + + + + + + _10874168409609149361 miAECMSxGwjxrcOKk0DII _17726690318409070815 mWkGo8xUdRIKgJ1DEUvvn + + + + + _13303058356268144138 mbViqhyIcr6lGWibuo3Im + + + + + muiDYQbmwLxL3PGrwWGeP + + mPdHdcAZ6XJhwf8wLtULI + + + mnSkEvR4SbDwQxj23xB1M + + + mgjPImSFwUcUKl9XTKqqB + + + + + + + + + + + + + + + mabeHDqoCFUg5Mty5oLni + + + mp3H4249LtCVDCYFqQqz4 + + + + _2920695669964880276.rows mWUoD50tT9HFGBNQCsjUC + 0 mECamByxBqjGyTShbPlRQ + + + + _3145974845315888936 mel3l7ZRXwnAEsy0Wfxj_ + 0 mmCJ670wA_VHgip7JZ1dW + + + + + mMRNM5hfPBWFjYCspldu3 + + + + + mNMDyj9J1Nt8auTKwp8ze + + + + + + mhxtTU7dvZHXCTSg8B8rx + unsigned meWm4MhzbcJwavtoh469w +_13303058356268144138 mKcKHr_bTagXAK_pf8btG + + + 0 mPdHdcAZ6XJhwf8wLtULI + + _13303058356268144138 mbG1GEmOdh2dXkJZ42sXo + + _17726690318409070815.size mwTQhkbVNQHd2Xw4EA4fj + + + mlqoNTA3LQoUJF6i5YDFc + + _13303058356268144138 mcstdE8Wwpam6tUMM45Sa + mgkSwnYHQivQIpeAwgr20 + _17726690318409070815 mFyKKLtdivGGDlk8sYzsf + + + _13303058356268144138 mDd5IIsnjfLI1lcygRsW3 + + + +.calculateExtrinsics mmmC9tOGiLK6UaJr0E5vz + + _3145974845315888936, _2920695669964880276, _14932605280544191270, _606330642723070475 mhyL_M5gnmQzwyHW45MdA + mlqoNTA3LQoUJF6i5YDFc + + + + + muuG2jhk4iNsA9KNmj6oA + + + + mOcs0qqtJYmueMnfTyCFx + + _14525273392272441420 mM3tRrWbRPqPOU3G4ShKT + + std mUCEzhGWrU8OYqcHVPlVW + + + numeric_limits mCALzjQ0bwpDnngl_oSsi + + + mnqZGwZqTTi1dekKxujAE + + + + mW1YUos9eL_9NmgJuSDH7 + + + + + + mBBHVSlvDGP5NVUfEuhuf + max mzeHK1hG1SYQMISNMWMB8 + + + + mhGXMe8LHJXydR9dMisHj + + + mVRbVdVjFvNmKzGv4WiNp + + + +const mgxs4jaOm5WhsuDH7hsbo + + + + +&_17126762063553264542:_17726690318409070815 mAnDeXfeHaujEzGBbrjil + + + mDzQQrEx5Ki0C6uDHU2cy + + + + + mlkEZnzYCXAgDnYDi5up3 + + _13303058356268144137 mRwjoMr_aqph4iL4nu8NS 0 mxdAvfSsdzliezc0uyUMk + + + ma9rnYFEs_TUiw_WyBflg + + moI11mwtxiOXpqDxK_aQL + _13303058356268144199 mCm219F3DHVwNe_CsrCeK 0 mriCvhMavpfheoLNc0eCD + + + _13303058356268144199 mlP1m6taP4mQVYA_j8Oxe + 4 mJTScPpWt8plE9Cz9fDU6 + + _13303058356268144199 mEZrtAN7pSZl5y4oEHd38 + msubWq7nTVSPilWqmTzkx + + + + + _13303058356268144137 mndDt3huhmUYGZC1vQmOq + + + cv maKLz6mCz5anFyVle_MtD + norm mFsSEF_3_iD2mT6nZG9QR + _17126762063553264542 mWkGo8xUdRIKgJ1DEUvvn + + _13303058356268144199 mwTp2D1d4PfxNNOzzUfhS + + + + -_17126762063553264542 mTjppsgNpY1Pjyv5Z_zMr + + + + mhORIPgMIfN3Fn8aCQBuU + + _13303058356268144199+1 muiDYQbmwLxL3PGrwWGeP + + + +%4 mEFd2D2UDF9SIoPfQtUv6 + mgkSwnYHQivQIpeAwgr20 + + + + mxdAvfSsdzliezc0uyUMk + + + + mWHxIxEh8g9mg3Hyipn8D + + + + mFlVjO0mLpwnCN5a1Quio + + + + _14525273392272441420 mYxohqgekcJ8HhaDZvWcX + + + + + _13303058356268144137 mlqM0snvYcrWCw2_QjhQi + + + + +_14525273392272441420 mif4ZCBkqdiqSYkR9AD0r _13303058356268144137 mlqoNTA3LQoUJF6i5YDFc + + + mnSkEvR4SbDwQxj23xB1M + + + + + mlkEZnzYCXAgDnYDi5up3 + + _15036404412276314769 mINcNsH05D0QZDej9wl4h + + mNhNSN2gx5KERe8tfdmgu + + + + mhORIPgMIfN3Fn8aCQBuU + _14525273392272441420 mtDHooAMb6ubWraYLa7pj + + std mBBHVSlvDGP5NVUfEuhuf + + + numeric_limits mYI2nkSxgJHf1pY1PttV1 + + mglDNKH5ah89GptW6H4Cu + + +mE4_Vrik0lveh4HNJUk1B + + mUCEzhGWrU8OYqcHVPlVW + +max mH1xQMRmYb0Y4RDp2hARz mzf4ZxeZY8wF2XnrdYK61 + + _15036404412276314769 mM3tRrWbRPqPOU3G4ShKT + + + + + + _14525273392272441420/ mtbP4KQJdh36UGELfV2zq + 4*std mfx1fLYDWN4YRZNnQEsJN max mhORIPgMIfN3Fn8aCQBuU + _17276638435886805939.cols,_17276638435886805939.rows muiDYQbmwLxL3PGrwWGeP mhyL_M5gnmQzwyHW45MdA mPdHdcAZ6XJhwf8wLtULI + + + mHcxzZHoWX11H4xEjR59T + + + + _15036404412276314769 mCm219F3DHVwNe_CsrCeK + + + + 0 mriCvhMavpfheoLNc0eCD + + mUFzn4yJGA8c9qnEcb9dH + mSa4WnWih0z4lSo9RYUGU + + _18062104616271777338.autoSize mgkSwnYHQivQIpeAwgr20 + + + + mJkMyi0NbVRDgE__LMR_m + _18062104616271777338.minSize mdKhcOUXVqyCMdccisL_a + _15036404412276314769* mFsSEF_3_iD2mT6nZG9QR 1-_18062104616271777338.ts mhyL_M5gnmQzwyHW45MdA + + + mJTScPpWt8plE9Cz9fDU6 + + mbYMUxVFybbviIFqRhN2f + + + + _6872264293741719360 mKcKHr_bTagXAK_pf8btG + + + + _17726690318409070815 mINcNsH05D0QZDej9wl4h + + + + + + + + mCvAz6nTbqhvwRULRgKe4 + + + + mfJA9NVd6FBgGhRSkkhhs + MarkerDetector_Impl mEMN2sRTwHcTUl7SNSw0d _10874168409609149361 mhORIPgMIfN3Fn8aCQBuU + + aruco maKLz6mCz5anFyVle_MtD + + + Marker &_17126762063553264542,cv mBBHVSlvDGP5NVUfEuhuf Mat _2920695669964880276,cv mUCEzhGWrU8OYqcHVPlVW + + Mat _14932605280544191270 mmCJ670wA_VHgip7JZ1dW + + + + mT_x8cqp5t43PgqNMR8gO + + + + + std mfx1fLYDWN4YRZNnQEsJN + + + + + vector mbG1GEmOdh2dXkJZ42sXo + + + + + + cv mYGfQUZmV9IjKAPVrLhZl + Point mBpPKNB5wfuTOV223BA2r + + + + + + &_14091102513355313451 mKcKHr_bTagXAK_pf8btG + + _17126762063553264542.contourPoints mINcNsH05D0QZDej9wl4h + + + vector mYfYoOWdsOLTDCIBT7npX + mSD7jHYN8mOif4_CBtIg6 + + mW1YUos9eL_9NmgJuSDH7 + + _16276718381659519112 mtbP4KQJdh36UGELfV2zq + + 4,-1 mgkSwnYHQivQIpeAwgr20 + mftnbgRvzOIVyL93HyyWt + + vector mlP1m6taP4mQVYA_j8Oxe + maOczvhF_v9OTsK70ZZut + + + + + + mYxohqgekcJ8HhaDZvWcX + + + + _3176008349054602175 mhORIPgMIfN3Fn8aCQBuU + 4,std maKLz6mCz5anFyVle_MtD +numeric_limits mCALzjQ0bwpDnngl_oSsi + + maOczvhF_v9OTsK70ZZut mEc9zv3P8LW8haIvtztwe + + mU808frSKQDZnEEU3Q3s9 + +max mFwk30320retpLBiICndp + + + + + + mmCJ670wA_VHgip7JZ1dW + mVOlbMaOu1U0SC2oeKIzP + + + + + m_owRLEm0gIJ4StPRwTkZ mtbP4KQJdh36UGELfV2zq + + unsigned mihBlyb7pwidO496a5_p1 + + _13303058356268144139 muQdV4OJL6V6gVxW6AdRy + + 0 mdmuaUz9iCkCckSUhcEv1 + + _13303058356268144139 mW1ds9XwNwevT5B2b3j8B _14091102513355313451.size mcznTYeCGOAygtXXAPYS_ + + + + + + mdmuaUz9iCkCckSUhcEv1 + _13303058356268144139 mUq8qfNXjDE9FPlMHvjf4 + + + + + + mAnDeXfeHaujEzGBbrjil + + + + mjbtcSgN5ZQfkGDsoYG4l + + + + + m_BNZbnU2Y1bOBnnPOF0b + + + + mhORIPgMIfN3Fn8aCQBuU + + + unsigned mMGij61UZUIIYyztVz9vN + + _13303058356268144136 ma6VjqdfajK4BX9gkoGiD 0 mVOlbMaOu1U0SC2oeKIzP + + + + _13303058356268144136 mca1GaR7Rv9qOZsisqKBB + + + 4 mPdHdcAZ6XJhwf8wLtULI + + _13303058356268144136 mUq8qfNXjDE9FPlMHvjf4 + + + + mlqM0snvYcrWCw2_QjhQi + + + + mDzQQrEx5Ki0C6uDHU2cy + + mnqZGwZqTTi1dekKxujAE + _13303058356268144198 mdKhcOUXVqyCMdccisL_a + mmmC9tOGiLK6UaJr0E5vz _14091102513355313451 mdF98bHO7yrxGJn0aQZVK + + + _13303058356268144139 mJtGCV8zXQjnVDVBVdvFZ + + .x-_17126762063553264542 mA4oXllup8K3T5dxkluRR + + _13303058356268144136 msdqcdg5NNrdQnc_PT1Ee + + .x mmCJ670wA_VHgip7JZ1dW + * mp3H4249LtCVDCYFqQqz4 + + + _14091102513355313451 mY2nz8M_6jpSxQZL8EYgU + + + + _13303058356268144139 msdqcdg5NNrdQnc_PT1Ee + + .x-_17126762063553264542 mY2nz8M_6jpSxQZL8EYgU + + _13303058356268144136 mUB1yrSrKOwldqxmCatN2 +.x mgkSwnYHQivQIpeAwgr20 + + + + + + mFlVjO0mLpwnCN5a1Quio + + + _14091102513355313451 mY2nz8M_6jpSxQZL8EYgU + + + + +_13303058356268144139 msdqcdg5NNrdQnc_PT1Ee + + .y-_17126762063553264542 mILaQGKCAmcKrYQNhgWUq + + + + _13303058356268144136 mwTp2D1d4PfxNNOzzUfhS + + + .y mlqM0snvYcrWCw2_QjhQi + * mmmC9tOGiLK6UaJr0E5vz + + + _14091102513355313451 mILaQGKCAmcKrYQNhgWUq + + _13303058356268144139 mo8MRbS3DUX_ZOlgmUSna + + .y-_17126762063553264542 mTjppsgNpY1Pjyv5Z_zMr + _13303058356268144136 mbViqhyIcr6lGWibuo3Im + + + + + .y muiDYQbmwLxL3PGrwWGeP + + + + + + mdmuaUz9iCkCckSUhcEv1 + + + mMNJIG0z6TLGgbjrhllmy + mp3H4249LtCVDCYFqQqz4 + + + + _13303058356268144198 mCALzjQ0bwpDnngl_oSsi + + _3176008349054602175 mFyKKLtdivGGDlk8sYzsf + + + _13303058356268144136 mo8MRbS3DUX_ZOlgmUSna + + + + mzf4ZxeZY8wF2XnrdYK61 + + mN0TszoCQmyzxmobsgV2H + + + + + _16276718381659519112 mTjppsgNpY1Pjyv5Z_zMr + + _13303058356268144136 mo8MRbS3DUX_ZOlgmUSna + + + ma6VjqdfajK4BX9gkoGiD + + + _13303058356268144139 mPdHdcAZ6XJhwf8wLtULI + + + _3176008349054602175 mTjppsgNpY1Pjyv5Z_zMr + + + + + + _13303058356268144136 mIkhxhgSNMt_JUZR7ce1U + + + mCm219F3DHVwNe_CsrCeK + + + + + + _13303058356268144198 mPdHdcAZ6XJhwf8wLtULI + + mICILgDpdCTDSJqQAn06L + + + + mDUyr1RAsHMG7u1BeTW3F + + + + + + + mgjPImSFwUcUKl9XTKqqB + + + + + + + mpHTdkvfapV5_Igrm_XSs + _10077272470817073709 mdmuaUz9iCkCckSUhcEv1 + + + + + + + mRzhpvoeHZK7yCqqzYDDp + miAECMSxGwjxrcOKk0DII + + mhORIPgMIfN3Fn8aCQBuU + + _16276718381659519112 mWkGo8xUdRIKgJ1DEUvvn + + + + 1 mJtGCV8zXQjnVDVBVdvFZ + mYxohqgekcJ8HhaDZvWcX + _16276718381659519112 mWkGo8xUdRIKgJ1DEUvvn + + + + 0 mIkhxhgSNMt_JUZR7ce1U + + + mAnDeXfeHaujEzGBbrjil + + mQDLRy0PKsddZ3xq0mn3V mFsSEF_3_iD2mT6nZG9QR + + + _16276718381659519112 mGYpOkNIG_qSvYXBOU9Vf + + 2 mbViqhyIcr6lGWibuo3Im + + + + mRHNkLPwUSnx20pmLgrTq + _16276718381659519112 mTjppsgNpY1Pjyv5Z_zMr + 1 mrpQVzv6u8gxvho1qUlil + + mfge932GrgApRFyCExy_M + _16276718381659519112 mFyKKLtdivGGDlk8sYzsf + + + + + +2 mo8MRbS3DUX_ZOlgmUSna + + + + mYfYoOWdsOLTDCIBT7npX + + + + _16276718381659519112 mWkGo8xUdRIKgJ1DEUvvn + + 0 mbViqhyIcr6lGWibuo3Im + + + + + + mXAYJa6osZ6HNTIEEBnr0 + mmCJ670wA_VHgip7JZ1dW + + + + _10077272470817073709 mif4ZCBkqdiqSYkR9AD0r + + + + muESrr63SaH81rmeBWzRi + + mriCvhMavpfheoLNc0eCD + + + mv1ijGQAKacWqWAusY8nc + + mMNJIG0z6TLGgbjrhllmy + + mtbP4KQJdh36UGELfV2zq + + + _16276718381659519112 mdF98bHO7yrxGJn0aQZVK + + 2 mrpQVzv6u8gxvho1qUlil + + mBpPKNB5wfuTOV223BA2r + + + + _16276718381659519112 mGYpOkNIG_qSvYXBOU9Vf + + + +1 mUB1yrSrKOwldqxmCatN2 + + + + mECamByxBqjGyTShbPlRQ + + + + _16276718381659519112 mA4oXllup8K3T5dxkluRR + + + 2 mwTp2D1d4PfxNNOzzUfhS + + + + mca1GaR7Rv9qOZsisqKBB _16276718381659519112 mZnfmoDANjVLDjZfzM5MR + + + 0 mJtGCV8zXQjnVDVBVdvFZ + + mycwFs63h7Mi3ggRkMEVm + + + _10077272470817073709 mif4ZCBkqdiqSYkR9AD0r + + muESrr63SaH81rmeBWzRi + + + mftnbgRvzOIVyL93HyyWt + + + + + else + _10077272470817073709 mu_nOcTFwUo8r0uNE351R + + + + mrYTPN06XEG4I2Q8GwVal + + + + + + mftnbgRvzOIVyL93HyyWt + + + + + + mihBlyb7pwidO496a5_p1 + + + + + + _5268611906073170262 mdKhcOUXVqyCMdccisL_a + 1 mdmuaUz9iCkCckSUhcEv1 + + + + + mJvv2tbrel2xOYjvgipUL + + + + + + mtbP4KQJdh36UGELfV2zq + + + +_10077272470817073709 mAnDeXfeHaujEzGBbrjil + + + + _5268611906073170262 mu_nOcTFwUo8r0uNE351R + -1 mJTScPpWt8plE9Cz9fDU6 + + + + vector mW1ds9XwNwevT5B2b3j8B + + + + + + Point2f mW1YUos9eL_9NmgJuSDH7 + _6417377122913179118 mVOlbMaOu1U0SC2oeKIzP + mwxm9pz2KjGAhBIIfFMf4 + + + mxD0ASUiBIk9J4KLYW_eX + + + + _2920695669964880276.empty mFwk30320retpLBiICndp + + + + + moejXze8_C6TCxb2bIzgq + + mRltbJjpZ8AzImbP6r6M4 + + _14932605280544191270.empty mwTQhkbVNQHd2Xw4EA4fj + + + mhyL_M5gnmQzwyHW45MdA + + + + mypSy3lS4LRIjRYTxVxzg + + + mtvEQgcnwdOR4zAMwLHDb + + + mtbP4KQJdh36UGELfV2zq + + unsigned moI11mwtxiOXpqDxK_aQL + + + + _13303058356268144138 myJHqW7fkn_72nVEhKeZ6 + + + + 0 mftnbgRvzOIVyL93HyyWt + + _13303058356268144138 mW1ds9XwNwevT5B2b3j8B + + _14091102513355313451.size mH1xQMRmYb0Y4RDp2hARz + + + mPdHdcAZ6XJhwf8wLtULI + + + + _13303058356268144138 mEZrtAN7pSZl5y4oEHd38 + + + muiDYQbmwLxL3PGrwWGeP + + + _6417377122913179118.push_back mFlVjO0mLpwnCN5a1Quio + + cv mEMN2sRTwHcTUl7SNSw0d + Point2f mhORIPgMIfN3Fn8aCQBuU + + + + _14091102513355313451 mY2nz8M_6jpSxQZL8EYgU + + + + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + + + + + + .x, _14091102513355313451 mY2nz8M_6jpSxQZL8EYgU _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee +.y mycwFs63h7Mi3ggRkMEVm + + + + mzf4ZxeZY8wF2XnrdYK61 + + mlqoNTA3LQoUJF6i5YDFc + mNhNSN2gx5KERe8tfdmgu + + + + + mmmC9tOGiLK6UaJr0E5vz + + + mnswinmeXuam57kXH7myI + + _2920695669964880276.empty mzeHK1hG1SYQMISNMWMB8 + + mgN2NPegMIWZaSlArqSpX + + + mRltbJjpZ8AzImbP6r6M4 + + _14932605280544191270.empty mcznTYeCGOAygtXXAPYS_ + + + msubWq7nTVSPilWqmTzkx + + + + + cv mdssZV6TB06aiisDwN1cX + undistortPoints mmmC9tOGiLK6UaJr0E5vz + _6417377122913179118, _6417377122913179118, _2920695669964880276, _14932605280544191270, cv myuwTFtkH1L5Be2OVY9rt + + + + Mat mFwk30320retpLBiICndp + + + , _2920695669964880276 mycwFs63h7Mi3ggRkMEVm + + mPdHdcAZ6XJhwf8wLtULI + + + mDUyr1RAsHMG7u1BeTW3F + + mUwTrZwI1VfAXDN69k3UA + + mfKhTg3wpiK_YhdQzWWcS + + + _6417377122913179118.reserve mFsSEF_3_iD2mT6nZG9QR + + + + +_14091102513355313451.size maHkatHu0Jap4oTaT5q4_ + + + + + + mgkSwnYHQivQIpeAwgr20 + + + + mlqoNTA3LQoUJF6i5YDFc + + + + + + + miGFoFUQX5urgUZ1Rewwt + + + + + + mHXoMWKZSiZYUvqmVkLF5 + + _13303058356268144073:_14091102513355313451 msubWq7nTVSPilWqmTzkx + + + _6417377122913179118.push_back miAECMSxGwjxrcOKk0DII + + cv maKLz6mCz5anFyVle_MtD + + + Point2f mp3H4249LtCVDCYFqQqz4 + + + + + + _13303058356268144073.x,_13303058356268144073.y mXAYJa6osZ6HNTIEEBnr0 + + + + mhyL_M5gnmQzwyHW45MdA mPdHdcAZ6XJhwf8wLtULI + + + mbYMUxVFybbviIFqRhN2f + + + + + vector mK5OxIt23gZzSiTA8trU8 + + + + + + std mEMN2sRTwHcTUl7SNSw0d + + vector mYfYoOWdsOLTDCIBT7npX + + cv myuwTFtkH1L5Be2OVY9rt + + Point2f mRHNkLPwUSnx20pmLgrTq + + + + mW1YUos9eL_9NmgJuSDH7 + + + + _6917161151118932890 mlqoNTA3LQoUJF6i5YDFc + + + + _6917161151118932890.resize mReDuVelSknxaDAoDEmwT + + + 4 mmCJ670wA_VHgip7JZ1dW + + + + mxdAvfSsdzliezc0uyUMk + + + + + + + mLBxgVrVeq7bTUcDGJqNH + + + miAECMSxGwjxrcOKk0DII + + + unsigned mSD7jHYN8mOif4_CBtIg6 + + + + + _13303058356268144137 mdKhcOUXVqyCMdccisL_a + + 0 mhGXMe8LHJXydR9dMisHj + + + _13303058356268144137 mqEAvVDOCXqrrwrTRByrM + + + + + + 4 mdmuaUz9iCkCckSUhcEv1 + + + _13303058356268144137 mt0bWs8kxCzTnBdtR9vKu + mycwFs63h7Mi3ggRkMEVm + + + mjbtcSgN5ZQfkGDsoYG4l + m_owRLEm0gIJ4StPRwTkZ + mFlVjO0mLpwnCN5a1Quio + + mdEzmAkZNQkKD1HrLnSSo + + + + _13303058356268144139 muQdV4OJL6V6gVxW6AdRy + + + + + mReDuVelSknxaDAoDEmwT + + mSD7jHYN8mOif4_CBtIg6 + + + + + + mzf4ZxeZY8wF2XnrdYK61 + + + +_16276718381659519112 mNDJrNgMXB1tBoFNaJO0d + + + _13303058356268144137 mJtGCV8zXQjnVDVBVdvFZ + + + + + + mhGXMe8LHJXydR9dMisHj + + + _13303058356268144139 ma43zKzGwyDT5C3mNdj6s miAECMSxGwjxrcOKk0DII + + + + meWm4MhzbcJwavtoh469w + + muiDYQbmwLxL3PGrwWGeP + + + + _16276718381659519112 mTjppsgNpY1Pjyv5Z_zMr + + + + + + mtbP4KQJdh36UGELfV2zq + _13303058356268144137 + 1 muiDYQbmwLxL3PGrwWGeP + % 4 mEFd2D2UDF9SIoPfQtUv6 + mJTScPpWt8plE9Cz9fDU6 + + _13303058356268144139 msMfR3R5kzP8SqAQ3DWTq + + _5268611906073170262 mmCJ670wA_VHgip7JZ1dW + + mfKhTg3wpiK_YhdQzWWcS + + + + mUFzn4yJGA8c9qnEcb9dH + + + + + + miAECMSxGwjxrcOKk0DII + + + + _13303058356268144139 mi0dc2wlXgNoHf9VPli9f + + + + + mp3H4249LtCVDCYFqQqz4 + + + + mP8l6554fUQhsCw2PetD2 mzf4ZxeZY8wF2XnrdYK61 + + + _14091102513355313451.size mdWkXjuaPd4Se0r0SdY1e + + m_YnlLsKBlim0LDKxc0Xy + + + + mnswinmeXuam57kXH7myI + + + + +_10077272470817073709 mmCJ670wA_VHgip7JZ1dW + + _13303058356268144139 myJHqW7fkn_72nVEhKeZ6 + + + + + + 0 mPdHdcAZ6XJhwf8wLtULI + moT0JKxDJVSALTDfSRUYM + + + + + + mWHxIxEh8g9mg3Hyipn8D + + mFlVjO0mLpwnCN5a1Quio + + + + + _13303058356268144139 mPlk6hpBhStcHkX9pfoTY + + 0 mvW7MwxFgHE1jUFn6bpuP + + _10077272470817073709 mhyL_M5gnmQzwyHW45MdA + + + + _13303058356268144139 mdKhcOUXVqyCMdccisL_a + + _14091102513355313451.size mdWkXjuaPd4Se0r0SdY1e + + - 1 mVOlbMaOu1U0SC2oeKIzP + + + + _6917161151118932890 mY2nz8M_6jpSxQZL8EYgU + + +_13303058356268144137 mJtGCV8zXQjnVDVBVdvFZ + + .push_back mFlVjO0mLpwnCN5a1Quio + + _6417377122913179118 mGYpOkNIG_qSvYXBOU9Vf + _13303058356268144139 mrpQVzv6u8gxvho1qUlil + + + mmCJ670wA_VHgip7JZ1dW + + + + + + mPdHdcAZ6XJhwf8wLtULI + mvw_MKiY3S1FcVNfJQCRT miAECMSxGwjxrcOKk0DII + _13303058356268144139 mnZ6t3BhMZ_1d7zzE72ah + + mmmC9tOGiLK6UaJr0E5vz + mCujczJix6jMpJcynoBiA + + + + + +muiDYQbmwLxL3PGrwWGeP + + + _16276718381659519112 mFyKKLtdivGGDlk8sYzsf mFlVjO0mLpwnCN5a1Quio + + _13303058356268144137 + 1 mlqM0snvYcrWCw2_QjhQi % 4 mrpQVzv6u8gxvho1qUlil + + mmCJ670wA_VHgip7JZ1dW + + mTFkOkggRsxkeMv25hiJW + mftnbgRvzOIVyL93HyyWt + + + + + + mbYMUxVFybbviIFqRhN2f + + + + mnSkEvR4SbDwQxj23xB1M + + + + vector mCALzjQ0bwpDnngl_oSsi + Point3f mRHNkLPwUSnx20pmLgrTq + + + + _17129155073204642077 mftnbgRvzOIVyL93HyyWt + + _17129155073204642077.resize miAECMSxGwjxrcOKk0DII + + 4 mAnDeXfeHaujEzGBbrjil + + mPdHdcAZ6XJhwf8wLtULI + + mNMDyj9J1Nt8auTKwp8ze miAECMSxGwjxrcOKk0DII + + + + unsigned mG7mr0Iq8BCEeADSwrCoW + _13303058356268144139 myJHqW7fkn_72nVEhKeZ6 + + 0 mdmuaUz9iCkCckSUhcEv1 + + + _13303058356268144139 mK5OxIt23gZzSiTA8trU8 + + _17129155073204642077.size mwTQhkbVNQHd2Xw4EA4fj + + mdmuaUz9iCkCckSUhcEv1 + + + _13303058356268144139 mwwJvnj2j3yLmklxxOEJQ + + + mzf4ZxeZY8wF2XnrdYK61 + + + + _5589556639929121196 mmmC9tOGiLK6UaJr0E5vz + + + + + +_6917161151118932890 mTjppsgNpY1Pjyv5Z_zMr + _13303058356268144139 mDd5IIsnjfLI1lcygRsW3 + + + + + + , _17129155073204642077 mFyKKLtdivGGDlk8sYzsf + + +_13303058356268144139 mwTp2D1d4PfxNNOzzUfhS + mgkSwnYHQivQIpeAwgr20 + + + + + + mVOlbMaOu1U0SC2oeKIzP + + + + + + + + + vector mca1GaR7Rv9qOZsisqKBB + + Point2f mRHNkLPwUSnx20pmLgrTq + + _15053120134632409437 mhGXMe8LHJXydR9dMisHj + _15053120134632409437.resize mReDuVelSknxaDAoDEmwT + + 4 mycwFs63h7Mi3ggRkMEVm + + + + mhGXMe8LHJXydR9dMisHj + + mtvEQgcnwdOR4zAMwLHDb + + mFlVjO0mLpwnCN5a1Quio unsigned mihBlyb7pwidO496a5_p1 + + + + + + _13303058356268144138 mKcKHr_bTagXAK_pf8btG + 0 mPdHdcAZ6XJhwf8wLtULI _13303058356268144138 mW1ds9XwNwevT5B2b3j8B + + + + + 4 mriCvhMavpfheoLNc0eCD + + _13303058356268144138 mBh4lc09qKYGXyU7FeqOv mAnDeXfeHaujEzGBbrjil + + _15053120134632409437 mZnfmoDANjVLDjZfzM5MR + + + _13303058356268144138 mbViqhyIcr6lGWibuo3Im + + + + mif4ZCBkqdiqSYkR9AD0r + _8396213235373312360 mp3H4249LtCVDCYFqQqz4 + + _17129155073204642077 mY2nz8M_6jpSxQZL8EYgU + + miAECMSxGwjxrcOKk0DII + + _13303058356268144138 - 1 mlqM0snvYcrWCw2_QjhQi % 4 mIkhxhgSNMt_JUZR7ce1U + , _17129155073204642077 mZnfmoDANjVLDjZfzM5MR + + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + mycwFs63h7Mi3ggRkMEVm + + mdmuaUz9iCkCckSUhcEv1 + + + + + + mJvv2tbrel2xOYjvgipUL + + miAECMSxGwjxrcOKk0DII + + mRltbJjpZ8AzImbP6r6M4 + +_2920695669964880276.empty mFwk30320retpLBiICndp + + + + + mBJ7M0ikk98KhD4Oi32wB + msFQPbyubcQTkvTYpFFPL + + + + + + _14932605280544191270.empty mdWkXjuaPd4Se0r0SdY1e mgkSwnYHQivQIpeAwgr20 + + + + _8160328761135174279 miAECMSxGwjxrcOKk0DII + + + + _15053120134632409437, _15053120134632409437, _2920695669964880276, _14932605280544191270 mAnDeXfeHaujEzGBbrjil mPdHdcAZ6XJhwf8wLtULI + + + m_owRLEm0gIJ4StPRwTkZ + + + mhORIPgMIfN3Fn8aCQBuU + + unsigned mMGij61UZUIIYyztVz9vN + + + + _13303058356268144139 mdKhcOUXVqyCMdccisL_a 0 mriCvhMavpfheoLNc0eCD + + + + _13303058356268144139 mqEAvVDOCXqrrwrTRByrM + 4 mriCvhMavpfheoLNc0eCD + + _13303058356268144139 mo7mKuzaX2h9vw2rEj5qh + + + mmCJ670wA_VHgip7JZ1dW + + + mLdYY4X2b7VOjtTSnd7Hj + + + + + + _17126762063553264542 mdF98bHO7yrxGJn0aQZVK + + + _13303058356268144139 mo8MRbS3DUX_ZOlgmUSna + muQdV4OJL6V6gVxW6AdRy + + + _15053120134632409437 mdF98bHO7yrxGJn0aQZVK _13303058356268144139 msdqcdg5NNrdQnc_PT1Ee + + mJTScPpWt8plE9Cz9fDU6 + + + mbYMUxVFybbviIFqRhN2f + + + + + + + mICILgDpdCTDSJqQAn06L + + + + + + + mKmIjE1RujJ5RSETUjqwW + + MarkerDetector_Impl mU808frSKQDZnEEU3Q3s9 + + + + _1548619269531313217 mhxtTU7dvZHXCTSg8B8rx MarkerCandidate &_3175967376861678913, mG7mr0Iq8BCEeADSwrCoW + + + + _3177068552486117874 muiDYQbmwLxL3PGrwWGeP + + + mjbtcSgN5ZQfkGDsoYG4l + + + + + ms9iveRK8Fk_QtPMDvDcP + moI11mwtxiOXpqDxK_aQL + + _13303058356268144139 mu_nOcTFwUo8r0uNE351R + + 0 mhGXMe8LHJXydR9dMisHj + + + + _13303058356268144139 mHkLXuUOlyX2vZI7w3FQj + + + + + +2 mVOlbMaOu1U0SC2oeKIzP + + _13303058356268144139 mBh4lc09qKYGXyU7FeqOv + + mgkSwnYHQivQIpeAwgr20 + + + mDzQQrEx5Ki0C6uDHU2cy + myYAiLHDT3JvFKUJCC_FN + _11941284328360913259 ma6VjqdfajK4BX9gkoGiD +_13303058356268144139 mdmuaUz9iCkCckSUhcEv1 + + + mF8CPQI5IssWjwlV2CXVE +_3176948340370061933 mu_nOcTFwUo8r0uNE351R + mSa4WnWih0z4lSo9RYUGU + + + + +_13303058356268144139 + 2 mzf4ZxeZY8wF2XnrdYK61 + + + + + % 4 mJTScPpWt8plE9Cz9fDU6 + + + + mUFzn4yJGA8c9qnEcb9dH + + + + mhxtTU7dvZHXCTSg8B8rx + _3175967376861678913 mA4oXllup8K3T5dxkluRR + + + + + + _11941284328360913259 msdqcdg5NNrdQnc_PT1Ee + .x mYxohqgekcJ8HhaDZvWcX +_3175967376861678913 mTjppsgNpY1Pjyv5Z_zMr + _3176948340370061933 mwTp2D1d4PfxNNOzzUfhS .x muiDYQbmwLxL3PGrwWGeP + mJkMyi0NbVRDgE__LMR_m + + + swap mFsSEF_3_iD2mT6nZG9QR + + + + _11941284328360913259,_3176948340370061933 mlqM0snvYcrWCw2_QjhQi + + mxdAvfSsdzliezc0uyUMk + + + + muuG2jhk4iNsA9KNmj6oA + + const mYKwa_OYBeVXzRPMa_mz6 + + _3257891606805124672 mRwjoMr_aqph4iL4nu8NS + + + + 3.14159f mVOlbMaOu1U0SC2oeKIzP + + + + const mnqZGwZqTTi1dekKxujAE + + + + + + _5268608437207054717 mu_nOcTFwUo8r0uNE351R + + + 3.14159/8.f mPdHdcAZ6XJhwf8wLtULI + + + + + const mWokjWH0MHqyBOx4j0Oac + + + + + + _12290827085925694194 mdKhcOUXVqyCMdccisL_a + + 3.*3.14159f/8.f mVOlbMaOu1U0SC2oeKIzP + + + + const mglDNKH5ah89GptW6H4Cu +_12290826968547181107 mKcKHr_bTagXAK_pf8btG + 5.f*3.14159f/8.f mdmuaUz9iCkCckSUhcEv1 + + + + + const maOczvhF_v9OTsK70ZZut + +_12290829632982753066 ma6VjqdfajK4BX9gkoGiD 7.f*3.14159f/8.f mxdAvfSsdzliezc0uyUMk + + + + + + + moI11mwtxiOXpqDxK_aQL + + + + + + _3177069355788807654 mdKhcOUXVqyCMdccisL_a + 0,_3177069355788807468 mM3tRrWbRPqPOU3G4ShKT + + + 0 mINcNsH05D0QZDej9wl4h + + mZHJfF8VODcHrGq0YEwM_ + + + + + + _16232574195069208446 mif4ZCBkqdiqSYkR9AD0r + + _3175967376861678913 mY2nz8M_6jpSxQZL8EYgU + +_3176948340370061933 mwTp2D1d4PfxNNOzzUfhS + + -_3175967376861678913 mY2nz8M_6jpSxQZL8EYgU + + + + + + _11941284328360913259 mUB1yrSrKOwldqxmCatN2 + mINcNsH05D0QZDej9wl4h + + + mnqZGwZqTTi1dekKxujAE + + + + + + _12315458030785690534 ma6VjqdfajK4BX9gkoGiD + + + + atan2 mFlVjO0mLpwnCN5a1Quio + _16232574195069208446.y,_16232574195069208446.x mmCJ670wA_VHgip7JZ1dW + mxdAvfSsdzliezc0uyUMk + + + + + + + mRzhpvoeHZK7yCqqzYDDp + miAECMSxGwjxrcOKk0DII + _5268608437207054717 mlP1m6taP4mQVYA_j8Oxe + + + + + _12315458030785690534 mQDLRy0PKsddZ3xq0mn3V + + _12315458030785690534 mYfYoOWdsOLTDCIBT7npX + + + + 3*_5268608437207054717 mXAYJa6osZ6HNTIEEBnr0 + + mjbtcSgN5ZQfkGDsoYG4l + + + _3177069355788807654 mu_nOcTFwUo8r0uNE351R _3177069355788807468 mCm219F3DHVwNe_CsrCeK + + + + _3177068552486117874 mPdHdcAZ6XJhwf8wLtULI + + + + maCQ9r5fSln_CXgRXGFvO + + + + + + mZQqomBcB_Prq89ftbAiD + + + + mabeHDqoCFUg5Mty5oLni + + mFlVjO0mLpwnCN5a1Quio + + + + -_5268608437207054717 mYfYoOWdsOLTDCIBT7npX + + + _12315458030785690534 mECamByxBqjGyTShbPlRQ _12315458030785690534 mYI2nkSxgJHf1pY1PttV1 _5268608437207054717 mlqM0snvYcrWCw2_QjhQi + + + + + mypSy3lS4LRIjRYTxVxzg + + + + + + + _3177069355788807654 mKcKHr_bTagXAK_pf8btG + + _3177068552486117874 mPdHdcAZ6XJhwf8wLtULI + + + _3177069355788807468 mdKhcOUXVqyCMdccisL_a + + + + + + 0 mftnbgRvzOIVyL93HyyWt + + + muuG2jhk4iNsA9KNmj6oA + + + muKP5B7qysoQRrYrwu_aG + + + + + + mvw_MKiY3S1FcVNfJQCRT + + + + + + mFsSEF_3_iD2mT6nZG9QR + -_12290827085925694194 mYI2nkSxgJHf1pY1PttV1 + + +_12315458030785690534 mQDLRy0PKsddZ3xq0mn3V + + _12315458030785690534 mCALzjQ0bwpDnngl_oSsi + + + + -_5268608437207054717 msubWq7nTVSPilWqmTzkx + + + + mT_x8cqp5t43PgqNMR8gO + + + + _3177069355788807654 mif4ZCBkqdiqSYkR9AD0r _3177068552486117874 mlqoNTA3LQoUJF6i5YDFc + + + + _3177069355788807468 mdKhcOUXVqyCMdccisL_a + + + + + +-_3177068552486117874 mriCvhMavpfheoLNc0eCD + + mDUyr1RAsHMG7u1BeTW3F + + mv1ijGQAKacWqWAusY8nc + + + + mabeHDqoCFUg5Mty5oLni + + + mhORIPgMIfN3Fn8aCQBuU + -_12290826968547181107 mYI2nkSxgJHf1pY1PttV1 + + + + + + _12315458030785690534 mOR5gj7K3yTraJVOrvmKy + + _12315458030785690534 mlP1m6taP4mQVYA_j8Oxe + + -_12290827085925694194 mAnDeXfeHaujEzGBbrjil + mfKhTg3wpiK_YhdQzWWcS + + + + _3177069355788807654 mM3tRrWbRPqPOU3G4ShKT + + + 0 mlqoNTA3LQoUJF6i5YDFc + + + + _3177069355788807468 mKcKHr_bTagXAK_pf8btG + + + + + + -_3177068552486117874 mdmuaUz9iCkCckSUhcEv1 + + + + maCQ9r5fSln_CXgRXGFvO + + mUwTrZwI1VfAXDN69k3UA mEwOO8zzJcEkF96gfFa1e + mtbP4KQJdh36UGELfV2zq + -_12290829632982753066 mW1ds9XwNwevT5B2b3j8B + + + + + _12315458030785690534 mQDLRy0PKsddZ3xq0mn3V + + + + + _12315458030785690534 mW1ds9XwNwevT5B2b3j8B + + + -_12290826968547181107 muiDYQbmwLxL3PGrwWGeP + + + mMRNM5hfPBWFjYCspldu3 + + + + _3177069355788807654 muQdV4OJL6V6gVxW6AdRy + + -_3177068552486117874 mftnbgRvzOIVyL93HyyWt + + + + + + + _3177069355788807468 mCm219F3DHVwNe_CsrCeK -_3177068552486117874 mxdAvfSsdzliezc0uyUMk + + + mgjPImSFwUcUKl9XTKqqB + + + + + mnkTvEdpCXelpIHLLqQno + + + + mabeHDqoCFUg5Mty5oLni + mmmC9tOGiLK6UaJr0E5vz + + mp3H4249LtCVDCYFqQqz4 + + + + + + -_3257891606805124672 mW1ds9XwNwevT5B2b3j8B + + + + + +_12315458030785690534 mbFGY3HJrKnP_L6H3dMsA + + + + + _12315458030785690534 mW1ds9XwNwevT5B2b3j8B + + -_12290829632982753066 mAnDeXfeHaujEzGBbrjil + + miAr40ThvnnZei4PQ8nft + + + mmmC9tOGiLK6UaJr0E5vz + +_12290829632982753066 mqEAvVDOCXqrrwrTRByrM + + + + + + _12315458030785690534 mKdH1o6rFuMJ1Fl0PA_sn + + _12315458030785690534 mCALzjQ0bwpDnngl_oSsi + + + + + + _3257891606805124672 msubWq7nTVSPilWqmTzkx + + + + mXAYJa6osZ6HNTIEEBnr0 + + mDzQQrEx5Ki0C6uDHU2cy + + + + _3177069355788807654 mRwjoMr_aqph4iL4nu8NS + -_3177068552486117874 mlqoNTA3LQoUJF6i5YDFc + + _3177069355788807468 mif4ZCBkqdiqSYkR9AD0r + +0 mxdAvfSsdzliezc0uyUMk + + + + + + + mnSkEvR4SbDwQxj23xB1M + + + mUwTrZwI1VfAXDN69k3UA + + + + + + mMNJIG0z6TLGgbjrhllmy + + + mmmC9tOGiLK6UaJr0E5vz + mhORIPgMIfN3Fn8aCQBuU + _12290826968547181107 mK5OxIt23gZzSiTA8trU8 + + + + + + _12315458030785690534 mOR5gj7K3yTraJVOrvmKy + _12315458030785690534 mbG1GEmOdh2dXkJZ42sXo + + _12290829632982753066 mmCJ670wA_VHgip7JZ1dW mhyL_M5gnmQzwyHW45MdA mnU2hwoI16_nZ7reLKJTr + + + + + + + _3177069355788807654 mu_nOcTFwUo8r0uNE351R + -_3177068552486117874 mxdAvfSsdzliezc0uyUMk + + + + + + _3177069355788807468 myJHqW7fkn_72nVEhKeZ6 + _3177068552486117874 mlqoNTA3LQoUJF6i5YDFc + + + + + + + mJOnXqKm3GBylSdRjpXAA + + + moT0JKxDJVSALTDfSRUYM + mUFzn4yJGA8c9qnEcb9dH mReDuVelSknxaDAoDEmwT + mp3H4249LtCVDCYFqQqz4 + + + + _12290827085925694194 mqEAvVDOCXqrrwrTRByrM + + _12315458030785690534 mvW7MwxFgHE1jUFn6bpuP + _12315458030785690534 mYfYoOWdsOLTDCIBT7npX + + _12290826968547181107 mzf4ZxeZY8wF2XnrdYK61 + + mmCJ670wA_VHgip7JZ1dW + mjbtcSgN5ZQfkGDsoYG4l + + + _3177069355788807654 mif4ZCBkqdiqSYkR9AD0r +_3177068552486117874 mdmuaUz9iCkCckSUhcEv1 + + + + + + + _3177069355788807468 myJHqW7fkn_72nVEhKeZ6 + + + _3177068552486117874 mVOlbMaOu1U0SC2oeKIzP + + + + + + + mgjPImSFwUcUKl9XTKqqB + + + + + + + _3175967376861678913 mFyKKLtdivGGDlk8sYzsf + _3176948340370061933 mUB1yrSrKOwldqxmCatN2 +.x mC7CcuPGpz81aizhogiZL + + + + _3177069355788807654 mlqoNTA3LQoUJF6i5YDFc + + + + + _3175967376861678913 mILaQGKCAmcKrYQNhgWUq + _3176948340370061933 mrpQVzv6u8gxvho1qUlil + + + + +.y mC7CcuPGpz81aizhogiZL + _3177069355788807468 mriCvhMavpfheoLNc0eCD + + _3175967376861678913 mTjppsgNpY1Pjyv5Z_zMr + _11941284328360913259 msdqcdg5NNrdQnc_PT1Ee + + + + .x mFKRUYDiDlNmwfGKdBg2S + + _3177069355788807654 mPdHdcAZ6XJhwf8wLtULI + _3175967376861678913 mILaQGKCAmcKrYQNhgWUq + + + + + + _11941284328360913259 mDd5IIsnjfLI1lcygRsW3 + + + + + .y mtL59O4fTIGPJKdcQHvhB + + + _3177069355788807468 mxdAvfSsdzliezc0uyUMk + + + + mnSkEvR4SbDwQxj23xB1M + + maCQ9r5fSln_CXgRXGFvO + + + + + + + + + + mihBlyb7pwidO496a5_p1 + + + MarkerDetector_Impl mfx1fLYDWN4YRZNnQEsJN + + + + + _13365150943186347431 mtbP4KQJdh36UGELfV2zq + cv mfx1fLYDWN4YRZNnQEsJN + + Size _10104164517741906567 msubWq7nTVSPilWqmTzkx + + + const mfKhTg3wpiK_YhdQzWWcS + + + + + + + mRzhpvoeHZK7yCqqzYDDp + mtbP4KQJdh36UGELfV2zq + _18062104616271777338.minSize mnZ6t3BhMZ_1d7zzE72ah + -1 mbFGY3HJrKnP_L6H3dMsA + + + + + + _18062104616271777338.minSize_pix maDn6NcmB5JPmBvJglMEd + + + + + + -1 mlqM0snvYcrWCw2_QjhQi + mo03bPDhF7WKTf8ndM1Bk + 0 mPdHdcAZ6XJhwf8wLtULI + + + mSD7jHYN8mOif4_CBtIg6 + + _17126222192490468606 myJHqW7fkn_72nVEhKeZ6 + + + std mUCEzhGWrU8OYqcHVPlVW + + + max mtbP4KQJdh36UGELfV2zq + + + + + + _10104164517741906567.width, _10104164517741906567.height msubWq7nTVSPilWqmTzkx + + + mINcNsH05D0QZDej9wl4h + + + + + + + mihBlyb7pwidO496a5_p1 + + + _9531480675436973396 muQdV4OJL6V6gVxW6AdRy + + + + + +0 mlqoNTA3LQoUJF6i5YDFc + + + mEwOO8zzJcEkF96gfFa1e + + + + + + mhORIPgMIfN3Fn8aCQBuU + + + + + + _18062104616271777338.minSize mWUoD50tT9HFGBNQCsjUC + -1 muiDYQbmwLxL3PGrwWGeP + + + + + + _9531480675436973396 myJHqW7fkn_72nVEhKeZ6 + + + + + + static_cast mCALzjQ0bwpDnngl_oSsi + + + mlkEZnzYCXAgDnYDi5up3 + + mE4_Vrik0lveh4HNJUk1B + + + + mtbP4KQJdh36UGELfV2zq + _18062104616271777338.minSize mlqM0snvYcrWCw2_QjhQi + + + +* static_cast mCALzjQ0bwpDnngl_oSsi + + + + mnqZGwZqTTi1dekKxujAE + + + + mtJAThUzPUAnb_DMXiQOL + + + + mFlVjO0mLpwnCN5a1Quio + + + + + + _17126222192490468606 muiDYQbmwLxL3PGrwWGeP + + + mPdHdcAZ6XJhwf8wLtULI + + + mNhNSN2gx5KERe8tfdmgu + + + + mhxtTU7dvZHXCTSg8B8rx + + _18062104616271777338.minSize_pix muOzaq9SXefX6wOasanyX + + + + -1 mlqM0snvYcrWCw2_QjhQi + + + _9531480675436973396 mRwjoMr_aqph4iL4nu8NS + + + + + std mBBHVSlvDGP5NVUfEuhuf + + + + min mFlVjO0mLpwnCN5a1Quio _18062104616271777338.minSize_pix, _9531480675436973396 mzf4ZxeZY8wF2XnrdYK61 + + + + mINcNsH05D0QZDej9wl4h + + + + myYaYWcsrnLoe6SxorDYt + + + _9531480675436973396 mPdHdcAZ6XJhwf8wLtULI + + + + + + + + maCQ9r5fSln_CXgRXGFvO + + + + + mU8SToe5QpPWgY0z9QAcm + MarkerDetector_Impl mfx1fLYDWN4YRZNnQEsJN + + + + + warp miAECMSxGwjxrcOKk0DII + + + + + + Mat& _16232574195069562409, Mat& _5268605234504081842, Size _3176948226119365859, vector mK5OxIt23gZzSiTA8trU8 + + + + Point2f mE4_Vrik0lveh4HNJUk1B + + + + _3225820074026295014 mAnDeXfeHaujEzGBbrjil + + + + mDzQQrEx5Ki0C6uDHU2cy + + + + + + + mMNJIG0z6TLGgbjrhllmy + + + + miAECMSxGwjxrcOKk0DII + _3225820074026295014.size mcznTYeCGOAygtXXAPYS_ + + mZk2lUQMDVDhOLQdg9s92 + + + + 4 mzf4ZxeZY8wF2XnrdYK61 + + throw cv mYGfQUZmV9IjKAPVrLhZl + Exception mhxtTU7dvZHXCTSg8B8rx + + + +9001, "\x5c\x78\x37\x30\x5c\x78\x36\x66\x5c\x78\x36\x39\x5c\x78\x36\x65\x5c\x78\x37\x34\x5c\x78\x32\x65\x5c\x78\x37\x33\x5c\x78\x36\x39\x5c\x78\x37\x61\x5c\x78\x36\x35\x5c\x78\x32\x38\x5c\x78\x32\x39\x5c\x78\x32\x31\x5c\x78\x33\x64\x5c\x78\x33\x34", "\x5c\x78\x34\x64\x5c\x78\x36\x31\x5c\x78\x37\x32\x5c\x78\x36\x62\x5c\x78\x36\x35\x5c\x78\x37\x32\x5c\x78\x34\x34\x5c\x78\x36\x35\x5c\x78\x37\x34\x5c\x78\x36\x35\x5c\x78\x36\x33\x5c\x78\x37\x34\x5c\x78\x36\x66\x5c\x78\x37\x32\x5c\x78\x35\x66\x5c\x78\x34\x39\x5c\x78\x36\x64\x5c\x78\x37\x30\x5c\x78\x36\x63\x5c\x78\x33\x61\x5c\x78\x33\x61\x5c\x78\x37\x37\x5c\x78\x36\x31\x5c\x78\x37\x32\x5c\x78\x37\x30", __FILE__, __LINE__ mhyL_M5gnmQzwyHW45MdA + + + mlqoNTA3LQoUJF6i5YDFc + + + + Point2f _10473289206739293354 mZnfmoDANjVLDjZfzM5MR + + 4 mDd5IIsnjfLI1lcygRsW3 + + , _9482907070712177146 mILaQGKCAmcKrYQNhgWUq + + + + + + 4 msdqcdg5NNrdQnc_PT1Ee + + + + mlqoNTA3LQoUJF6i5YDFc + + + + + + + m_BNZbnU2Y1bOBnnPOF0b + + mFsSEF_3_iD2mT6nZG9QR + + + + + + mSD7jHYN8mOif4_CBtIg6 + + _13303058356268144138 mCm219F3DHVwNe_CsrCeK + + + 0 mINcNsH05D0QZDej9wl4h + + + + _13303058356268144138 mHkLXuUOlyX2vZI7w3FQj + + + + + + 4 mxdAvfSsdzliezc0uyUMk + + + _13303058356268144138 mo7mKuzaX2h9vw2rEj5qh + + + mgkSwnYHQivQIpeAwgr20 + + _9482907070712177146 mY2nz8M_6jpSxQZL8EYgU + + + + + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + ma6VjqdfajK4BX9gkoGiD + + _3225820074026295014 mGYpOkNIG_qSvYXBOU9Vf + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + mVOlbMaOu1U0SC2oeKIzP + + + + + + + _10473289206739293354 mWkGo8xUdRIKgJ1DEUvvn + + +0 msdqcdg5NNrdQnc_PT1Ee + + + + + mRwjoMr_aqph4iL4nu8NS + + mmmC9tOGiLK6UaJr0E5vz + + + Point2f mReDuVelSknxaDAoDEmwT + + +0, 0 mlqM0snvYcrWCw2_QjhQi + + mgkSwnYHQivQIpeAwgr20 + + + mhGXMe8LHJXydR9dMisHj + + + + + _10473289206739293354 mNDJrNgMXB1tBoFNaJO0d + + + 1 msdqcdg5NNrdQnc_PT1Ee + muQdV4OJL6V6gVxW6AdRy + Point2f mhxtTU7dvZHXCTSg8B8rx + + static_cast mca1GaR7Rv9qOZsisqKBB + + mnECjbnhLknZie3Z5iHP2 + + + + m_j6ZkbEfLCgUqtaolYTp + + + mFsSEF_3_iD2mT6nZG9QR + + + + + + _3176948226119365859.width - 1 mzf4ZxeZY8wF2XnrdYK61 + + , 0.f mycwFs63h7Mi3ggRkMEVm + mJTScPpWt8plE9Cz9fDU6 + + _10473289206739293354 mFyKKLtdivGGDlk8sYzsf + + 2 mUB1yrSrKOwldqxmCatN2 + mCm219F3DHVwNe_CsrCeK + + Point2f mSa4WnWih0z4lSo9RYUGU + + static_cast mYI2nkSxgJHf1pY1PttV1 + + mWokjWH0MHqyBOx4j0Oac + + mEc9zv3P8LW8haIvtztwe + + + + + + mFlVjO0mLpwnCN5a1Quio + _3176948226119365859.width - 1 mhyL_M5gnmQzwyHW45MdA + + + + + + , static_cast mK5OxIt23gZzSiTA8trU8 + mYKwa_OYBeVXzRPMa_mz6 + mE4_Vrik0lveh4HNJUk1B + + mSa4WnWih0z4lSo9RYUGU + + _3176948226119365859.height - 1 mAnDeXfeHaujEzGBbrjil + mlqM0snvYcrWCw2_QjhQi + mxdAvfSsdzliezc0uyUMk + + _10473289206739293354 mFyKKLtdivGGDlk8sYzsf + + + 3 mIkhxhgSNMt_JUZR7ce1U + mKcKHr_bTagXAK_pf8btG + + Point2f mmmC9tOGiLK6UaJr0E5vz + 0.f, static_cast mlP1m6taP4mQVYA_j8Oxe + + mYKwa_OYBeVXzRPMa_mz6 + + + + mtJAThUzPUAnb_DMXiQOL + + + + + miAECMSxGwjxrcOKk0DII + + + +_3176948226119365859.height - 1 mhyL_M5gnmQzwyHW45MdA + + msubWq7nTVSPilWqmTzkx + + + mINcNsH05D0QZDej9wl4h + + + Mat _13303058356268144331 myJHqW7fkn_72nVEhKeZ6 + + getPerspectiveTransform mReDuVelSknxaDAoDEmwT + + + + + _9482907070712177146, _10473289206739293354 mycwFs63h7Mi3ggRkMEVm mxdAvfSsdzliezc0uyUMk + + + + + + cv mEMN2sRTwHcTUl7SNSw0d + + warpPerspective mtbP4KQJdh36UGELfV2zq + + +_16232574195069562409, _5268605234504081842, _13303058356268144331, _3176948226119365859, cv mEMN2sRTwHcTUl7SNSw0d + + + +INTER_LINEAR mycwFs63h7Mi3ggRkMEVm + + mftnbgRvzOIVyL93HyyWt + + + + + + mLfKYVMLDthbyvvLerNPJ + + mRrVhT0WkQauAZEUJHKOK + + mriCvhMavpfheoLNc0eCD + + mJOnXqKm3GBylSdRjpXAA + + + + + + + + mG7mr0Iq8BCEeADSwrCoW + + + + MarkerDetector_Impl mpJt2kGThF7wb3VNzG38b + + + + + _16109434691388891984 mhxtTU7dvZHXCTSg8B8rx + + + + const vector mK5OxIt23gZzSiTA8trU8 + Point2f mYxohqgekcJ8HhaDZvWcX + + + & _13303058356268144201 msubWq7nTVSPilWqmTzkx + + + + + + + mypSy3lS4LRIjRYTxVxzg + + + mCujczJix6jMpJcynoBiA + _5268611907573087124 mu_nOcTFwUo8r0uNE351R + + + + 0 mxdAvfSsdzliezc0uyUMk + m_owRLEm0gIJ4StPRwTkZ + mReDuVelSknxaDAoDEmwT + + + unsigned mCujczJix6jMpJcynoBiA + + + + + + _13303058356268144138 mKcKHr_bTagXAK_pf8btG + + 0 mlqoNTA3LQoUJF6i5YDFc + + _13303058356268144138 mbG1GEmOdh2dXkJZ42sXo + + + + _13303058356268144201.size maHkatHu0Jap4oTaT5q4_ + + + mriCvhMavpfheoLNc0eCD + + + + _13303058356268144138 mkGHGzUDDVqHIjIdYGe6S + muiDYQbmwLxL3PGrwWGeP + + mypSy3lS4LRIjRYTxVxzg + + + + mG7mr0Iq8BCEeADSwrCoW + + _16232574195069558079 mCm219F3DHVwNe_CsrCeK + + + + + mSa4WnWih0z4lSo9RYUGU + _13303058356268144138 + 1 mycwFs63h7Mi3ggRkMEVm + + % _13303058356268144201.size mFwk30320retpLBiICndp + + mdmuaUz9iCkCckSUhcEv1 + + + _5268611907573087124 mhMsdnRaOV1FZ69nEgvbs + + static_cast mqEAvVDOCXqrrwrTRByrM + + meWm4MhzbcJwavtoh469w + +mtJAThUzPUAnb_DMXiQOL + + + + + mp3H4249LtCVDCYFqQqz4 sqrt miAECMSxGwjxrcOKk0DII + + mFsSEF_3_iD2mT6nZG9QR _13303058356268144201 mA4oXllup8K3T5dxkluRR + + +_13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + + + +.x - _13303058356268144201 mY2nz8M_6jpSxQZL8EYgU + + + _16232574195069558079 mbViqhyIcr6lGWibuo3Im + + + +.x mhyL_M5gnmQzwyHW45MdA + + + + + + * mSa4WnWih0z4lSo9RYUGU + +_13303058356268144201 mWkGo8xUdRIKgJ1DEUvvn + _13303058356268144138 mJtGCV8zXQjnVDVBVdvFZ + + .x - _13303058356268144201 mNDJrNgMXB1tBoFNaJO0d + + _16232574195069558079 mUB1yrSrKOwldqxmCatN2 + + + + + + .x mmCJ670wA_VHgip7JZ1dW + + + + mhORIPgMIfN3Fn8aCQBuU + + + + _13303058356268144201 mILaQGKCAmcKrYQNhgWUq + + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + + + + .y - _13303058356268144201 mZnfmoDANjVLDjZfzM5MR + _16232574195069558079 mbViqhyIcr6lGWibuo3Im + + .y mXAYJa6osZ6HNTIEEBnr0 + * mReDuVelSknxaDAoDEmwT + + + _13303058356268144201 mA4oXllup8K3T5dxkluRR + _13303058356268144138 mbViqhyIcr6lGWibuo3Im + .y - _13303058356268144201 mWkGo8xUdRIKgJ1DEUvvn + + + + + + _16232574195069558079 mJtGCV8zXQjnVDVBVdvFZ + + + +.y mmCJ670wA_VHgip7JZ1dW + + + mzf4ZxeZY8wF2XnrdYK61 + + + mlqM0snvYcrWCw2_QjhQi + + + + mPdHdcAZ6XJhwf8wLtULI + + + mJOnXqKm3GBylSdRjpXAA + + + + mLfKYVMLDthbyvvLerNPJ + _5268611907573087124 mINcNsH05D0QZDej9wl4h + + + mnSkEvR4SbDwQxj23xB1M + + + + + mc6SGgM2Uzvo_wy5KTima +MarkerDetector_Impl mBBHVSlvDGP5NVUfEuhuf + _5589556639929121196 mSa4WnWih0z4lSo9RYUGU + const std mfx1fLYDWN4YRZNnQEsJN + vector mHkLXuUOlyX2vZI7w3FQj + + cv maKLz6mCz5anFyVle_MtD + + Point2f mW1YUos9eL_9NmgJuSDH7 + & _14067181347882760969, cv maKLz6mCz5anFyVle_MtD + + + + Point3f& _15087904812230018442 mzf4ZxeZY8wF2XnrdYK61 + + + + + mMRNM5hfPBWFjYCspldu3 + + + + + + + mOcs0qqtJYmueMnfTyCFx + +_3176948348563158707, _3257891898253592020, _3176948348563158706, _3257891898253592021 mxdAvfSsdzliezc0uyUMk + + + + _3176948348563158707 muQdV4OJL6V6gVxW6AdRy + + + + + + _3257891898253592020 mKcKHr_bTagXAK_pf8btG + + + _14067181347882760969 mA4oXllup8K3T5dxkluRR + + + + + + 0 mDd5IIsnjfLI1lcygRsW3 + + +.x mftnbgRvzOIVyL93HyyWt + + + + + + + _3176948348563158706 mif4ZCBkqdiqSYkR9AD0r + _3257891898253592021 mif4ZCBkqdiqSYkR9AD0r + _14067181347882760969 mWkGo8xUdRIKgJ1DEUvvn + +0 mrpQVzv6u8gxvho1qUlil + .y mftnbgRvzOIVyL93HyyWt + + + + + + m_owRLEm0gIJ4StPRwTkZ + + + + mFsSEF_3_iD2mT6nZG9QR unsigned meWm4MhzbcJwavtoh469w + + + + + + _13303058356268144138 mRwjoMr_aqph4iL4nu8NS + + 1 mhGXMe8LHJXydR9dMisHj + + + + + _13303058356268144138 mCALzjQ0bwpDnngl_oSsi _14067181347882760969.size mFwk30320retpLBiICndp mJTScPpWt8plE9Cz9fDU6 + + + + _13303058356268144138 mcstdE8Wwpam6tUMM45Sa + mhyL_M5gnmQzwyHW45MdA + + + + mnU2hwoI16_nZ7reLKJTr + + + + mJvv2tbrel2xOYjvgipUL + + + miAECMSxGwjxrcOKk0DII + + _14067181347882760969 mWkGo8xUdRIKgJ1DEUvvn + + + _13303058356268144138 mrpQVzv6u8gxvho1qUlil + + + +.x mHkLXuUOlyX2vZI7w3FQj + + + + _3176948348563158707 mAnDeXfeHaujEzGBbrjil + + _3176948348563158707 mRwjoMr_aqph4iL4nu8NS + + + + + + _14067181347882760969 mFyKKLtdivGGDlk8sYzsf + + _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee + + + .x mlqoNTA3LQoUJF6i5YDFc + + + mRzhpvoeHZK7yCqqzYDDp + + + miAECMSxGwjxrcOKk0DII + + _14067181347882760969 mFyKKLtdivGGDlk8sYzsf _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + + .x mRHNkLPwUSnx20pmLgrTq + + + _3257891898253592020 msubWq7nTVSPilWqmTzkx + + + + _3257891898253592020 mRwjoMr_aqph4iL4nu8NS + + + + _14067181347882760969 mTjppsgNpY1Pjyv5Z_zMr + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + + + + + .x mxdAvfSsdzliezc0uyUMk + mRzhpvoeHZK7yCqqzYDDp + mmmC9tOGiLK6UaJr0E5vz + + _14067181347882760969 mdF98bHO7yrxGJn0aQZVK + _13303058356268144138 mJtGCV8zXQjnVDVBVdvFZ + + .y mYfYoOWdsOLTDCIBT7npX + _3176948348563158706 muiDYQbmwLxL3PGrwWGeP + + + _3176948348563158706 mM3tRrWbRPqPOU3G4ShKT + + + + _14067181347882760969 mFyKKLtdivGGDlk8sYzsf + + +_13303058356268144138 mEFd2D2UDF9SIoPfQtUv6 + .y mftnbgRvzOIVyL93HyyWt + + mNhNSN2gx5KERe8tfdmgu + + mhORIPgMIfN3Fn8aCQBuU _14067181347882760969 mILaQGKCAmcKrYQNhgWUq + + + + + _13303058356268144138 mDd5IIsnjfLI1lcygRsW3 + + .y m_j6ZkbEfLCgUqtaolYTp + + + + _3257891898253592021 mmCJ670wA_VHgip7JZ1dW + + _3257891898253592021 ma6VjqdfajK4BX9gkoGiD + + _14067181347882760969 mA4oXllup8K3T5dxkluRR + + + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS .y mPdHdcAZ6XJhwf8wLtULI + + + mCvAz6nTbqhvwRULRgKe4 + + + + + + + const mMGij61UZUIIYyztVz9vN + + _16643961442089568442 muQdV4OJL6V6gVxW6AdRy + + + + + + static_cast mqEAvVDOCXqrrwrTRByrM + + mP8l6554fUQhsCw2PetD2 + + +mE4_Vrik0lveh4HNJUk1B + + mFlVjO0mLpwnCN5a1Quio + _14067181347882760969.size mf_hJsy06Me1epT4PRx_l + + + + + + msubWq7nTVSPilWqmTzkx + mINcNsH05D0QZDej9wl4h + + + Mat _13303058356268142351 mp3H4249LtCVDCYFqQqz4 +_16643961442089568442, 2, CV_32FC1, Scalar mSa4WnWih0z4lSo9RYUGU + 0 mhyL_M5gnmQzwyHW45MdA + + + + mmCJ670wA_VHgip7JZ1dW + mlqoNTA3LQoUJF6i5YDFc + + + Mat _13303058356268142348 mhxtTU7dvZHXCTSg8B8rx +_16643961442089568442, 1, CV_32FC1, Scalar mFlVjO0mLpwnCN5a1Quio + 0 mXAYJa6osZ6HNTIEEBnr0 mzf4ZxeZY8wF2XnrdYK61 + mxdAvfSsdzliezc0uyUMk + + Mat _13303058356268144267 mriCvhMavpfheoLNc0eCD + + + + mJvv2tbrel2xOYjvgipUL + mmmC9tOGiLK6UaJr0E5vz + + + + _3257891898253592020 - _3176948348563158707 mEc9zv3P8LW8haIvtztwe + + + + _3257891898253592021 - _3176948348563158706 msubWq7nTVSPilWqmTzkx + + + + + mJkMyi0NbVRDgE__LMR_m + + + + + mLBxgVrVeq7bTUcDGJqNH + mFsSEF_3_iD2mT6nZG9QR + + + mMGij61UZUIIYyztVz9vN + + _13303058356268144138 mRwjoMr_aqph4iL4nu8NS + + + 0 mJTScPpWt8plE9Cz9fDU6 + _13303058356268144138 mca1GaR7Rv9qOZsisqKBB + + _16643961442089568442 mlqoNTA3LQoUJF6i5YDFc + + + + + _13303058356268144138 mi940TUip6nLdi0tWD33F + + + + mgkSwnYHQivQIpeAwgr20 + + + + + mnU2hwoI16_nZ7reLKJTr + + _13303058356268142351.at mK5OxIt23gZzSiTA8trU8 + + + mOcs0qqtJYmueMnfTyCFx mtJAThUzPUAnb_DMXiQOL + + + + + + mhxtTU7dvZHXCTSg8B8rx _13303058356268144138, 0 mhyL_M5gnmQzwyHW45MdA + + + mif4ZCBkqdiqSYkR9AD0r + _14067181347882760969 mNDJrNgMXB1tBoFNaJO0d + _13303058356268144138 mrpQVzv6u8gxvho1qUlil + + + + .x mJTScPpWt8plE9Cz9fDU6 + _13303058356268142351.at mW1ds9XwNwevT5B2b3j8B + + + mI_QuD605u2H3qQFyuTju + + + + mE4_Vrik0lveh4HNJUk1B + + mmmC9tOGiLK6UaJr0E5vz + + _13303058356268144138, 1 mgkSwnYHQivQIpeAwgr20 + + + + + + muQdV4OJL6V6gVxW6AdRy + + + + + 1. mJTScPpWt8plE9Cz9fDU6 + + _13303058356268142348.at mYfYoOWdsOLTDCIBT7npX + + + + mOcs0qqtJYmueMnfTyCFx + + mW1YUos9eL_9NmgJuSDH7 + + + mFsSEF_3_iD2mT6nZG9QR + +_13303058356268144138, 0 mAnDeXfeHaujEzGBbrjil + + + + mCm219F3DHVwNe_CsrCeK + + + _14067181347882760969 mY2nz8M_6jpSxQZL8EYgU + + + + + + _13303058356268144138 mEFd2D2UDF9SIoPfQtUv6 + + + .y mlqoNTA3LQoUJF6i5YDFc + + + + + mCvAz6nTbqhvwRULRgKe4 + + + + + solve mSa4WnWih0z4lSo9RYUGU _13303058356268142351, _13303058356268142348, _13303058356268144267, DECOMP_SVD mycwFs63h7Mi3ggRkMEVm + + + + + + mPdHdcAZ6XJhwf8wLtULI + + + + _15087904812230018442 ma6VjqdfajK4BX9gkoGiD + + + + Point3f miAECMSxGwjxrcOKk0DII + + + +_13303058356268144267.at mca1GaR7Rv9qOZsisqKBB + mI_QuD605u2H3qQFyuTju + + + + + + mE4_Vrik0lveh4HNJUk1B + + + + + + mhxtTU7dvZHXCTSg8B8rx + + + + + + 0, 0 mlqM0snvYcrWCw2_QjhQi + + + , -1., _13303058356268144267.at mca1GaR7Rv9qOZsisqKBB + + mglDNKH5ah89GptW6H4Cu + + mRHNkLPwUSnx20pmLgrTq + + + + mFsSEF_3_iD2mT6nZG9QR + + 1, 0 mzf4ZxeZY8wF2XnrdYK61 + + mmCJ670wA_VHgip7JZ1dW + + + mftnbgRvzOIVyL93HyyWt + + + + + + + muuG2jhk4iNsA9KNmj6oA + + + else + mMRNM5hfPBWFjYCspldu3 + + + mA9OyoOle98msK0BnFc8I + + + + mReDuVelSknxaDAoDEmwT + + mP8l6554fUQhsCw2PetD2 + + + + + _13303058356268144138 mKcKHr_bTagXAK_pf8btG + 0 mriCvhMavpfheoLNc0eCD + + + + + + _13303058356268144138 mCALzjQ0bwpDnngl_oSsi + + + + + + _16643961442089568442 mdmuaUz9iCkCckSUhcEv1 + + + + + + _13303058356268144138 mkGHGzUDDVqHIjIdYGe6S + + + + + + mhyL_M5gnmQzwyHW45MdA + + + mMRNM5hfPBWFjYCspldu3 + + + + + + + _13303058356268142351.at mW1ds9XwNwevT5B2b3j8B + + + + mglDNKH5ah89GptW6H4Cu + + m_j6ZkbEfLCgUqtaolYTp + + + + mhxtTU7dvZHXCTSg8B8rx +_13303058356268144138, 0 mlqM0snvYcrWCw2_QjhQi + + + + + + mif4ZCBkqdiqSYkR9AD0r + _14067181347882760969 mY2nz8M_6jpSxQZL8EYgU + + _13303058356268144138 mbViqhyIcr6lGWibuo3Im + + .y mVOlbMaOu1U0SC2oeKIzP + + _13303058356268142351.at mYI2nkSxgJHf1pY1PttV1 + + mlkEZnzYCXAgDnYDi5up3 + + + + mtJAThUzPUAnb_DMXiQOL + + mFsSEF_3_iD2mT6nZG9QR _13303058356268144138, 1 msubWq7nTVSPilWqmTzkx + + + + mKcKHr_bTagXAK_pf8btG + + 1. mftnbgRvzOIVyL93HyyWt + + _13303058356268142348.at mqEAvVDOCXqrrwrTRByrM + mnqZGwZqTTi1dekKxujAE + + +mE4_Vrik0lveh4HNJUk1B + mhxtTU7dvZHXCTSg8B8rx + + + _13303058356268144138, 0 mmCJ670wA_VHgip7JZ1dW + + + + + + myJHqW7fkn_72nVEhKeZ6 + + + + _14067181347882760969 mNDJrNgMXB1tBoFNaJO0d + + + + + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + + + + .x mriCvhMavpfheoLNc0eCD + + + + mICILgDpdCTDSJqQAn06L + + + + solve mSa4WnWih0z4lSo9RYUGU +_13303058356268142351, _13303058356268142348, _13303058356268144267, DECOMP_SVD mAnDeXfeHaujEzGBbrjil + + mftnbgRvzOIVyL93HyyWt + + + _15087904812230018442 mCm219F3DHVwNe_CsrCeK + + + + + + Point3f mFlVjO0mLpwnCN5a1Quio + + + -1., _13303058356268144267.at mca1GaR7Rv9qOZsisqKBB + maOczvhF_v9OTsK70ZZut + + mE4_Vrik0lveh4HNJUk1B + + + + + mhORIPgMIfN3Fn8aCQBuU + + + 0, 0 mhyL_M5gnmQzwyHW45MdA + + , _13303058356268144267.at mW1ds9XwNwevT5B2b3j8B + + + + mOcs0qqtJYmueMnfTyCFx mel3l7ZRXwnAEsy0Wfxj_ + + mhxtTU7dvZHXCTSg8B8rx + 1, 0 mmCJ670wA_VHgip7JZ1dW + + + + mlqM0snvYcrWCw2_QjhQi + + + + mPdHdcAZ6XJhwf8wLtULI + + + maCQ9r5fSln_CXgRXGFvO + + + + + + mgjPImSFwUcUKl9XTKqqB + + + + + + + + +Point2f MarkerDetector_Impl myuwTFtkH1L5Be2OVY9rt + + _8396213235373312360 mFlVjO0mLpwnCN5a1Quio + + const cv mdssZV6TB06aiisDwN1cX Point3f& _17129155073204649235, const cv mYGfQUZmV9IjKAPVrLhZl + Point3f& _17129155073204649234 mXAYJa6osZ6HNTIEEBnr0 + + mJkMyi0NbVRDgE__LMR_m + + + Mat _13303058356268142351 mReDuVelSknxaDAoDEmwT + 2, 2, CV_32FC1, Scalar mSa4WnWih0z4lSo9RYUGU + + + 0 mycwFs63h7Mi3ggRkMEVm + + + + + + mXAYJa6osZ6HNTIEEBnr0 + mftnbgRvzOIVyL93HyyWt + + + + + Mat _13303058356268142348 mhORIPgMIfN3Fn8aCQBuU + + + 2, 1, CV_32FC1, Scalar mhORIPgMIfN3Fn8aCQBuU + + 0 mzf4ZxeZY8wF2XnrdYK61 + mmCJ670wA_VHgip7JZ1dW + + + mdmuaUz9iCkCckSUhcEv1 + + Mat _13303058356268144267 mPdHdcAZ6XJhwf8wLtULI + + + _13303058356268142351.at mca1GaR7Rv9qOZsisqKBB + + + + + + mOcs0qqtJYmueMnfTyCFx + + + + + +mel3l7ZRXwnAEsy0Wfxj_ + + + + + + mFsSEF_3_iD2mT6nZG9QR + + + + 0, 0 mzf4ZxeZY8wF2XnrdYK61 + myJHqW7fkn_72nVEhKeZ6 + + + + + + _17129155073204649235.x mftnbgRvzOIVyL93HyyWt + _13303058356268142351.at mK5OxIt23gZzSiTA8trU8 + + + + maISPbNJKXWB2QqsuuExM + + mYxohqgekcJ8HhaDZvWcX + + mtbP4KQJdh36UGELfV2zq + + 0, 1 mgkSwnYHQivQIpeAwgr20 + + mCm219F3DHVwNe_CsrCeK + + + _17129155073204649235.y mxdAvfSsdzliezc0uyUMk + + + + + + _13303058356268142348.at mqEAvVDOCXqrrwrTRByrM + mnqZGwZqTTi1dekKxujAE + + + +mW1YUos9eL_9NmgJuSDH7 + + + + + mFlVjO0mLpwnCN5a1Quio + 0, 0 msubWq7nTVSPilWqmTzkx + mif4ZCBkqdiqSYkR9AD0r + + + -_17129155073204649235.z mlqoNTA3LQoUJF6i5YDFc + + + _13303058356268142351.at mYI2nkSxgJHf1pY1PttV1 + + maOczvhF_v9OTsK70ZZut + + + mYxohqgekcJ8HhaDZvWcX + + + mhxtTU7dvZHXCTSg8B8rx + 1, 0 mycwFs63h7Mi3ggRkMEVm + + + + mM3tRrWbRPqPOU3G4ShKT + + _17129155073204649234.x mftnbgRvzOIVyL93HyyWt + + + _13303058356268142351.at mK5OxIt23gZzSiTA8trU8 mYKwa_OYBeVXzRPMa_mz6 mel3l7ZRXwnAEsy0Wfxj_ + + mp3H4249LtCVDCYFqQqz4 +1, 1 msubWq7nTVSPilWqmTzkx + + + + mif4ZCBkqdiqSYkR9AD0r + + + + + + _17129155073204649234.y mINcNsH05D0QZDej9wl4h + + + + _13303058356268142348.at mbG1GEmOdh2dXkJZ42sXo + mglDNKH5ah89GptW6H4Cu + mel3l7ZRXwnAEsy0Wfxj_ + + mhORIPgMIfN3Fn8aCQBuU + + + 1, 0 mhyL_M5gnmQzwyHW45MdA + + mCm219F3DHVwNe_CsrCeK + + -_17129155073204649234.z mdmuaUz9iCkCckSUhcEv1 + + + + + solve mp3H4249LtCVDCYFqQqz4 + + + + + + _13303058356268142351, _13303058356268142348, _13303058356268144267, DECOMP_SVD muiDYQbmwLxL3PGrwWGeP + + mftnbgRvzOIVyL93HyyWt + + + mGbN63kjoGx6fvYq0oiYN + Point2f mSa4WnWih0z4lSo9RYUGU + + + + + + _13303058356268144267.at mlP1m6taP4mQVYA_j8Oxe + + mWokjWH0MHqyBOx4j0Oac + + mE4_Vrik0lveh4HNJUk1B + mhORIPgMIfN3Fn8aCQBuU 0, 0 mhyL_M5gnmQzwyHW45MdA + + , _13303058356268144267.at mca1GaR7Rv9qOZsisqKBB + maOczvhF_v9OTsK70ZZut + + mW1YUos9eL_9NmgJuSDH7 + mSa4WnWih0z4lSo9RYUGU + + 1, 0 mXAYJa6osZ6HNTIEEBnr0 + mycwFs63h7Mi3ggRkMEVm mPdHdcAZ6XJhwf8wLtULI + + mnSkEvR4SbDwQxj23xB1M + + + + + + + + + + + + + + + mKmIjE1RujJ5RSETUjqwW + + + + + + MarkerDetector_Impl mEMN2sRTwHcTUl7SNSw0d + + + + + +_10815521206485692603 mtbP4KQJdh36UGELfV2zq + + + + + + Mat _17276638435886805939, std mdssZV6TB06aiisDwN1cX + vector mbG1GEmOdh2dXkJZ42sXo + std mYGfQUZmV9IjKAPVrLhZl + + vector mW1ds9XwNwevT5B2b3j8B + cv mEMN2sRTwHcTUl7SNSw0d + Point migVyykpmr2io3DNlFdHK + + + + + + & _10998538416191004035 msubWq7nTVSPilWqmTzkx + + mMRNM5hfPBWFjYCspldu3 + + + + + + + drawContours mp3H4249LtCVDCYFqQqz4 + _17276638435886805939, _10998538416191004035, -1, Scalar mSa4WnWih0z4lSo9RYUGU + + + + 255, 0, 255 mgkSwnYHQivQIpeAwgr20 + + mXAYJa6osZ6HNTIEEBnr0 + mriCvhMavpfheoLNc0eCD + + + mgjPImSFwUcUKl9XTKqqB + + + + + + mKqJtaKtNNFCDA9awnods + + + + + + MarkerDetector_Impl mpJt2kGThF7wb3VNzG38b + _13747571233701806900 mtbP4KQJdh36UGELfV2zq + + Mat& _16232574195069562409, vector mCALzjQ0bwpDnngl_oSsi + + Point mE4_Vrik0lveh4HNJUk1B + & _14091102513355313451, Scalar _12505068097757366359 mmCJ670wA_VHgip7JZ1dW + mT_x8cqp5t43PgqNMR8gO + + + maB_pNl4zuODt3oqXg9EB + + + + + mFsSEF_3_iD2mT6nZG9QR + + + + unsigned mP8l6554fUQhsCw2PetD2 +_13303058356268144138 myJHqW7fkn_72nVEhKeZ6 + + + + + 0 mdmuaUz9iCkCckSUhcEv1 + _13303058356268144138 mK5OxIt23gZzSiTA8trU8 + + + + + + _14091102513355313451.size mcznTYeCGOAygtXXAPYS_ + + + mriCvhMavpfheoLNc0eCD + + + + + + _13303058356268144138 mEZrtAN7pSZl5y4oEHd38 + mAnDeXfeHaujEzGBbrjil + + + mjbtcSgN5ZQfkGDsoYG4l + + + + + cv myuwTFtkH1L5Be2OVY9rt + + rectangle mFsSEF_3_iD2mT6nZG9QR + + + +_16232574195069562409, _14091102513355313451 mWkGo8xUdRIKgJ1DEUvvn + + _13303058356268144138 mJtGCV8zXQjnVDVBVdvFZ + + + , _14091102513355313451 mA4oXllup8K3T5dxkluRR + + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + +, _12505068097757366359 mXAYJa6osZ6HNTIEEBnr0 + + + mxdAvfSsdzliezc0uyUMk + + mgjPImSFwUcUKl9XTKqqB + + + + maCQ9r5fSln_CXgRXGFvO + + + + myqrAJLu9GRcs5sFEN1xM + + + + MarkerDetector_Impl myuwTFtkH1L5Be2OVY9rt + + + _10891860653827325848 mReDuVelSknxaDAoDEmwT + + + Mat& _16232574195069562409, vector mW1ds9XwNwevT5B2b3j8B + + + + + + Point m_j6ZkbEfLCgUqtaolYTp + + & _14091102513355313451, Scalar _12505068097757366359, moI11mwtxiOXpqDxK_aQL + _11719114631568207584 mgkSwnYHQivQIpeAwgr20 + mfKhTg3wpiK_YhdQzWWcS + + + mA9OyoOle98msK0BnFc8I + mReDuVelSknxaDAoDEmwT + + + + unsigned moI11mwtxiOXpqDxK_aQL + + + _13303058356268144138 ma6VjqdfajK4BX9gkoGiD + + 0 mINcNsH05D0QZDej9wl4h + _13303058356268144138 mlP1m6taP4mQVYA_j8Oxe + + + + + + _14091102513355313451.size mwTQhkbVNQHd2Xw4EA4fj + mJTScPpWt8plE9Cz9fDU6 + + + + _13303058356268144138 mo7mKuzaX2h9vw2rEj5qh + mAnDeXfeHaujEzGBbrjil + + mfKhTg3wpiK_YhdQzWWcS + + + + + cv myuwTFtkH1L5Be2OVY9rt + + line mFsSEF_3_iD2mT6nZG9QR + + _16232574195069562409, _14091102513355313451 mILaQGKCAmcKrYQNhgWUq + + _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee + + + , _14091102513355313451 mFyKKLtdivGGDlk8sYzsf mhxtTU7dvZHXCTSg8B8rx + + + + + + _13303058356268144138 + 1 mlqM0snvYcrWCw2_QjhQi + % _14091102513355313451.size mKpq3GwvJxRduE5RsGgGP + mwTp2D1d4PfxNNOzzUfhS + + + + , _12505068097757366359,_11719114631568207584 msubWq7nTVSPilWqmTzkx + mhGXMe8LHJXydR9dMisHj + + + mDUyr1RAsHMG7u1BeTW3F + + mDUyr1RAsHMG7u1BeTW3F + + + + + + + + + mKmIjE1RujJ5RSETUjqwW + + + MarkerDetector_Impl myuwTFtkH1L5Be2OVY9rt + + + + + + _5695532306146282654 mhORIPgMIfN3Fn8aCQBuU + + Mat _5268605234504081842, const vector mW1ds9XwNwevT5B2b3j8B + + Marker mYxohqgekcJ8HhaDZvWcX + + & _14642194608118973580 mycwFs63h7Mi3ggRkMEVm + + mMRNM5hfPBWFjYCspldu3 + + + + + maB_pNl4zuODt3oqXg9EB + miAECMSxGwjxrcOKk0DII +unsigned mdEzmAkZNQkKD1HrLnSSo + + + + + + _13303058356268144138 muQdV4OJL6V6gVxW6AdRy + + 0 mJTScPpWt8plE9Cz9fDU6 + + _13303058356268144138 mlP1m6taP4mQVYA_j8Oxe + + + _14642194608118973580.size mcznTYeCGOAygtXXAPYS_ + + + + mhGXMe8LHJXydR9dMisHj _13303058356268144138 mwwJvnj2j3yLmklxxOEJQ mgkSwnYHQivQIpeAwgr20 + + mjbtcSgN5ZQfkGDsoYG4l + + + + + + + cv mU808frSKQDZnEEU3Q3s9 + line mmmC9tOGiLK6UaJr0E5vz + + + +_5268605234504081842, _14642194608118973580 mY2nz8M_6jpSxQZL8EYgU + _13303058356268144138 mwTp2D1d4PfxNNOzzUfhS + mNDJrNgMXB1tBoFNaJO0d + 0 mUB1yrSrKOwldqxmCatN2 + + + + + + , _14642194608118973580 mWkGo8xUdRIKgJ1DEUvvn + + + _13303058356268144138 mJtGCV8zXQjnVDVBVdvFZ mTjppsgNpY1Pjyv5Z_zMr + + + + + + 1 mEFd2D2UDF9SIoPfQtUv6 + + + + + + , cv mdssZV6TB06aiisDwN1cX + + Scalar miAECMSxGwjxrcOKk0DII + + + 255, 0, 0 mmCJ670wA_VHgip7JZ1dW + + + , 2 mycwFs63h7Mi3ggRkMEVm + + + + + mINcNsH05D0QZDej9wl4h + + + cv myuwTFtkH1L5Be2OVY9rt + + + line mFsSEF_3_iD2mT6nZG9QR + + _5268605234504081842, _14642194608118973580 mY2nz8M_6jpSxQZL8EYgU + + + + + _13303058356268144138 mJtGCV8zXQjnVDVBVdvFZ + + + + + + mY2nz8M_6jpSxQZL8EYgU + + + 1 mUB1yrSrKOwldqxmCatN2 + + + + + + , _14642194608118973580 mFyKKLtdivGGDlk8sYzsf + + + + + +_13303058356268144138 mDd5IIsnjfLI1lcygRsW3 + + mNDJrNgMXB1tBoFNaJO0d + + + + + + 2 mIkhxhgSNMt_JUZR7ce1U + + + , cv maKLz6mCz5anFyVle_MtD Scalar mp3H4249LtCVDCYFqQqz4 + + 255, 0, 0 mzf4ZxeZY8wF2XnrdYK61 + + + + + + , 2 mmCJ670wA_VHgip7JZ1dW + + + mPdHdcAZ6XJhwf8wLtULI + + + + + cv mUCEzhGWrU8OYqcHVPlVW + + + line mp3H4249LtCVDCYFqQqz4 + _5268605234504081842, _14642194608118973580 mA4oXllup8K3T5dxkluRR + + + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + + + mILaQGKCAmcKrYQNhgWUq +2 mJtGCV8zXQjnVDVBVdvFZ + , _14642194608118973580 mY2nz8M_6jpSxQZL8EYgU + + + _13303058356268144138 mUB1yrSrKOwldqxmCatN2 + + mILaQGKCAmcKrYQNhgWUq + + 3 mEFd2D2UDF9SIoPfQtUv6 + , cv mpJt2kGThF7wb3VNzG38b + + + + Scalar mtbP4KQJdh36UGELfV2zq + + + 255, 0, 0 muiDYQbmwLxL3PGrwWGeP + + + + + + , 2 mzf4ZxeZY8wF2XnrdYK61 + + + mVOlbMaOu1U0SC2oeKIzP + + + + cv mUCEzhGWrU8OYqcHVPlVW + + + + line mmmC9tOGiLK6UaJr0E5vz + + _5268605234504081842, _14642194608118973580 mFyKKLtdivGGDlk8sYzsf _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + mWkGo8xUdRIKgJ1DEUvvn + + 3 mbViqhyIcr6lGWibuo3Im + , _14642194608118973580 mTjppsgNpY1Pjyv5Z_zMr + + _13303058356268144138 mUB1yrSrKOwldqxmCatN2 + + mdF98bHO7yrxGJn0aQZVK + + + + + 0 msdqcdg5NNrdQnc_PT1Ee + + , cv mEMN2sRTwHcTUl7SNSw0d + Scalar mp3H4249LtCVDCYFqQqz4 + + + + 255, 0, 0 mXAYJa6osZ6HNTIEEBnr0 + + , 2 mhyL_M5gnmQzwyHW45MdA + + + + mPdHdcAZ6XJhwf8wLtULI + + mgjPImSFwUcUKl9XTKqqB + + + + + + mgjPImSFwUcUKl9XTKqqB + + + + + mKqJtaKtNNFCDA9awnods MarkerDetector_Impl mEMN2sRTwHcTUl7SNSw0d + + + + +setMarkerLabeler miAECMSxGwjxrcOKk0DII + + + + + + cv maKLz6mCz5anFyVle_MtD + + + Ptr mK5OxIt23gZzSiTA8trU8 + + + MarkerLabeler mE4_Vrik0lveh4HNJUk1B + + _13776510099302020409 mlqM0snvYcrWCw2_QjhQi + + + mLdYY4X2b7VOjtTSnd7Hj + + + _4383831888714590158 mCm219F3DHVwNe_CsrCeK + _13776510099302020409 mPdHdcAZ6XJhwf8wLtULI + + + mhl3Z6oGBbP13ZxehUcg9 + + + mfJA9NVd6FBgGhRSkkhhs MarkerDetector_Impl mEMN2sRTwHcTUl7SNSw0d + + setDictionary mhORIPgMIfN3Fn8aCQBuU + moI11mwtxiOXpqDxK_aQL + + + + + +_1265885183454069381, + mlkEZnzYCXAgDnYDi5up3 + _1582275183843417612 mAnDeXfeHaujEzGBbrjil + + + + + mLdYY4X2b7VOjtTSnd7Hj + + _4383831888714590158 mM3tRrWbRPqPOU3G4ShKT + MarkerLabeler myuwTFtkH1L5Be2OVY9rt + + + create mhxtTU7dvZHXCTSg8B8rx + miAECMSxGwjxrcOKk0DII Dictionary mUCEzhGWrU8OYqcHVPlVW + + DICT_TYPES mmCJ670wA_VHgip7JZ1dW + + + + + + _1265885183454069381, _1582275183843417612 mmCJ670wA_VHgip7JZ1dW + + mdmuaUz9iCkCckSUhcEv1 + + + + _18062104616271777338.error_correction_rate mKcKHr_bTagXAK_pf8btG + + _1582275183843417612 mriCvhMavpfheoLNc0eCD + _18062104616271777338.dictionary muQdV4OJL6V6gVxW6AdRy + + + aruco mYGfQUZmV9IjKAPVrLhZl + + Dictionary maKLz6mCz5anFyVle_MtD + + getTypeString mhxtTU7dvZHXCTSg8B8rx + + mhORIPgMIfN3Fn8aCQBuU + + + + +Dictionary myuwTFtkH1L5Be2OVY9rt + DICT_TYPES mmCJ670wA_VHgip7JZ1dW + + + + + + _1265885183454069381 mgkSwnYHQivQIpeAwgr20 + + mVOlbMaOu1U0SC2oeKIzP + + + + + mhl3Z6oGBbP13ZxehUcg9 + + + + + + + + + + + myqrAJLu9GRcs5sFEN1xM + MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + + + + + + setDictionary mSa4WnWih0z4lSo9RYUGU + + string _1265885183454069381, mOcs0qqtJYmueMnfTyCFx + + + + + + _1582275183843417612 mAnDeXfeHaujEzGBbrjil + + + mfKhTg3wpiK_YhdQzWWcS + + + + moNuUrvhPRwgFBZS8fSa1 + + + _4657944431535098742 muQdV4OJL6V6gVxW6AdRy mNDJrNgMXB1tBoFNaJO0d + + + mEFd2D2UDF9SIoPfQtUv6 + + + + + + miAECMSxGwjxrcOKk0DII + + mWokjWH0MHqyBOx4j0Oac + + _13303058356268144138 muiDYQbmwLxL3PGrwWGeP + mT_x8cqp5t43PgqNMR8gO + + + std mBBHVSlvDGP5NVUfEuhuf + + stringstream _5268611907574360399 mVOlbMaOu1U0SC2oeKIzP + + + + + + _5268611907574360399 mOk7NgrdfVmJx9axvYv9F + + _13303058356268144138 mJTScPpWt8plE9Cz9fDU6 mLfKYVMLDthbyvvLerNPJ +_5268611907574360399.str maHkatHu0Jap4oTaT5q4_ + mINcNsH05D0QZDej9wl4h + + + mgjPImSFwUcUKl9XTKqqB + + + mftnbgRvzOIVyL93HyyWt + + + + + + _18062104616271777338.dictionary mCm219F3DHVwNe_CsrCeK + + + _1265885183454069381 mVOlbMaOu1U0SC2oeKIzP + + + _4383831888714590158 mKcKHr_bTagXAK_pf8btG + + + + MarkerLabeler mUCEzhGWrU8OYqcHVPlVW + + + create mSa4WnWih0z4lSo9RYUGU + + + _1265885183454069381, _4657944431535098742 mtbP4KQJdh36UGELfV2zq + + + + + + _1582275183843417612 mhyL_M5gnmQzwyHW45MdA + + mXAYJa6osZ6HNTIEEBnr0 + mxdAvfSsdzliezc0uyUMk + + + _18062104616271777338.error_correction_rate mu_nOcTFwUo8r0uNE351R + + + +_1582275183843417612 mINcNsH05D0QZDej9wl4h + + maCQ9r5fSln_CXgRXGFvO + + + + + + + + +cv mfx1fLYDWN4YRZNnQEsJN + + + + +Mat MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + + getThresholdedImage mReDuVelSknxaDAoDEmwT + mxNiL7NRse0iP2D2VgJvE + + + + + + _5268611906072959276 msubWq7nTVSPilWqmTzkx + + + + + + + mfKhTg3wpiK_YhdQzWWcS + + + + + + mwQUfI7G4pBH6IJQiBjmU + mFsSEF_3_iD2mT6nZG9QR + + +_16594497104544919971.size mH1xQMRmYb0Y4RDp2hARz + + + + + + mnZ6t3BhMZ_1d7zzE72ah + + + + 0 msubWq7nTVSPilWqmTzkx + + mTAavMivNX5WuUrRQXoEf + + cv mYGfQUZmV9IjKAPVrLhZl + Mat mdWkXjuaPd4Se0r0SdY1e + + mhGXMe8LHJXydR9dMisHj + + mMNJIG0z6TLGgbjrhllmy + + mhxtTU7dvZHXCTSg8B8rx + + + _5268611906072959276 moE42zHNBVjnlCdllZAkS + + _16594497104544919971.size mzeHK1hG1SYQMISNMWMB8 + + + + + mhyL_M5gnmQzwyHW45MdA + + + _5268611906072959276 mif4ZCBkqdiqSYkR9AD0r + + _16594497104544919971.size mKpq3GwvJxRduE5RsGgGP + + -1 mVOlbMaOu1U0SC2oeKIzP + + + + + maoHwm5lyecyelmN95sur + _16594497104544919971 mNDJrNgMXB1tBoFNaJO0d + + _5268611906072959276 mDd5IIsnjfLI1lcygRsW3 + + + + mftnbgRvzOIVyL93HyyWt + + + mhl3Z6oGBbP13ZxehUcg9 + + + + + + + mc6SGgM2Uzvo_wy5KTima + MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + + _8160328761135174279 mmmC9tOGiLK6UaJr0E5vz + vector mHkLXuUOlyX2vZI7w3FQj + + + cv mdssZV6TB06aiisDwN1cX +Point2f m_j6ZkbEfLCgUqtaolYTp _16232574195069562409, vector mK5OxIt23gZzSiTA8trU8 + + + + cv mpJt2kGThF7wb3VNzG38b + Point2f mRHNkLPwUSnx20pmLgrTq + &_5268605234504081842, const Mat &_2920695669964880276, const Mat &_14932605280544191270 mzf4ZxeZY8wF2XnrdYK61 + + + + mMRNM5hfPBWFjYCspldu3 + + + + + + + + cv mfx1fLYDWN4YRZNnQEsJN + + Mat _3257878217983167715 mdKhcOUXVqyCMdccisL_a + cv mU808frSKQDZnEEU3Q3s9 + Mat mp3H4249LtCVDCYFqQqz4 + + + + + 3, 1, CV_32FC1, cv mfx1fLYDWN4YRZNnQEsJN + + + + + + Scalar mfx1fLYDWN4YRZNnQEsJN + + + all mmmC9tOGiLK6UaJr0E5vz + + + + + + 0 mzf4ZxeZY8wF2XnrdYK61 + mAnDeXfeHaujEzGBbrjil + + mINcNsH05D0QZDej9wl4h + + + + cv mBBHVSlvDGP5NVUfEuhuf + + + + + + Mat _3175884290294458214 mM3tRrWbRPqPOU3G4ShKT + + + + + + _3257878217983167715.clone mcznTYeCGOAygtXXAPYS_ + + + + mriCvhMavpfheoLNc0eCD + + + + + + + + vector mW1ds9XwNwevT5B2b3j8B + + + + cv mpJt2kGThF7wb3VNzG38b Point3f mtJAThUzPUAnb_DMXiQOL + _15604885210959594850 mhGXMe8LHJXydR9dMisHj + + + + + + + m_BNZbnU2Y1bOBnnPOF0b + + + + + + mhORIPgMIfN3Fn8aCQBuU +unsigned mMGij61UZUIIYyztVz9vN + + + _13303058356268144138 mdKhcOUXVqyCMdccisL_a + + + + 0 mlqoNTA3LQoUJF6i5YDFc + _13303058356268144138 mHkLXuUOlyX2vZI7w3FQj + + _16232574195069562409.size mzeHK1hG1SYQMISNMWMB8 + mdmuaUz9iCkCckSUhcEv1 + + + + _13303058356268144138 mo7mKuzaX2h9vw2rEj5qh + + + + + + mzf4ZxeZY8wF2XnrdYK61 + + + + _15604885210959594850.push_back mhORIPgMIfN3Fn8aCQBuU + + + + + +cv maKLz6mCz5anFyVle_MtD Point3f mhxtTU7dvZHXCTSg8B8rx + + + mSa4WnWih0z4lSo9RYUGU + _16232574195069562409 mGYpOkNIG_qSvYXBOU9Vf + _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee +.x - _2920695669964880276.at mqEAvVDOCXqrrwrTRByrM mnECjbnhLknZie3Z5iHP2 + + mtJAThUzPUAnb_DMXiQOL + + + + mReDuVelSknxaDAoDEmwT + + + + 0, 2 muiDYQbmwLxL3PGrwWGeP + + mlqM0snvYcrWCw2_QjhQi + + + / _2920695669964880276.at mK5OxIt23gZzSiTA8trU8 + + + + mnqZGwZqTTi1dekKxujAE + + mW1YUos9eL_9NmgJuSDH7 mmmC9tOGiLK6UaJr0E5vz + +0, 0 mlqM0snvYcrWCw2_QjhQi + + , + mtbP4KQJdh36UGELfV2zq + + + + _16232574195069562409 mFyKKLtdivGGDlk8sYzsf + + _13303058356268144138 mIkhxhgSNMt_JUZR7ce1U + + .y - _2920695669964880276.at mbG1GEmOdh2dXkJZ42sXo + + + + mOcs0qqtJYmueMnfTyCFx + + mel3l7ZRXwnAEsy0Wfxj_ + + + mmmC9tOGiLK6UaJr0E5vz + 1, 2 mAnDeXfeHaujEzGBbrjil + + + mgkSwnYHQivQIpeAwgr20 + + / _2920695669964880276.at mW1ds9XwNwevT5B2b3j8B + + mI_QuD605u2H3qQFyuTju + + mtJAThUzPUAnb_DMXiQOL + mmmC9tOGiLK6UaJr0E5vz + + + + 1, 1 mAnDeXfeHaujEzGBbrjil + + + + , + 1 mXAYJa6osZ6HNTIEEBnr0 + + mgkSwnYHQivQIpeAwgr20 + + + + + + mhGXMe8LHJXydR9dMisHj + + + + + cv mfx1fLYDWN4YRZNnQEsJN + + + +projectPoints mFlVjO0mLpwnCN5a1Quio + + + + _15604885210959594850, _3257878217983167715, _3175884290294458214, _2920695669964880276, _14932605280544191270, _5268605234504081842 mlqM0snvYcrWCw2_QjhQi mJTScPpWt8plE9Cz9fDU6 + + mnSkEvR4SbDwQxj23xB1M + + + + mc6SGgM2Uzvo_wy5KTima + +MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + + + + saveParamsToFile mSa4WnWih0z4lSo9RYUGU + + + const std mBBHVSlvDGP5NVUfEuhuf + + string &_3257891857586418487 mhyL_M5gnmQzwyHW45MdA + + const mN0TszoCQmyzxmobsgV2H + + + + + cv mYGfQUZmV9IjKAPVrLhZl + + + FileStorage _16232574195041746640 mmmC9tOGiLK6UaJr0E5vz + + + + _3257891857586418487, cv mUCEzhGWrU8OYqcHVPlVW + + + + + + FileStorage mdssZV6TB06aiisDwN1cX + + + + + + WRITE mgkSwnYHQivQIpeAwgr20 + + + mdmuaUz9iCkCckSUhcEv1 + + + + + mikiSyOnVry6pvQ1Ds28H + mxD0ASUiBIk9J4KLYW_eX + + + + + + _16232574195041746640.isOpened maHkatHu0Jap4oTaT5q4_ + + + mgkSwnYHQivQIpeAwgr20 + throw std mBBHVSlvDGP5NVUfEuhuf + + + + runtime_error mmmC9tOGiLK6UaJr0E5vz + + + + "\x5c\x78\x34\x33\x5c\x78\x36\x66\x5c\x78\x37\x35\x5c\x78\x36\x63\x5c\x78\x36\x34\x5c\x78\x32\x30\x5c\x78\x36\x65\x5c\x78\x36\x66\x5c\x78\x37\x34\x5c\x78\x32\x30\x5c\x78\x36\x66\x5c\x78\x37\x30\x5c\x78\x36\x35\x5c\x78\x36\x65\x5c\x78\x32\x30"+_3257891857586418487 mlqM0snvYcrWCw2_QjhQi + + + + + + mdmuaUz9iCkCckSUhcEv1 + + + + + _18062104616271777338.save mFlVjO0mLpwnCN5a1Quio + + _16232574195041746640 mycwFs63h7Mi3ggRkMEVm + + mJTScPpWt8plE9Cz9fDU6 + + maCQ9r5fSln_CXgRXGFvO + + + + + + mwu5s8ye7pYEdPIYXjU5h + + + + MarkerDetector_Impl maKLz6mCz5anFyVle_MtD + + + loadParamsFromFile mmmC9tOGiLK6UaJr0E5vz + + + const std mdssZV6TB06aiisDwN1cX + string &_3257891857586418487 mycwFs63h7Mi3ggRkMEVm + mJkMyi0NbVRDgE__LMR_m + + + cv mYGfQUZmV9IjKAPVrLhZl + FileStorage _16232574195041746640 mp3H4249LtCVDCYFqQqz4 + + + +_3257891857586418487, cv mpJt2kGThF7wb3VNzG38b + FileStorage mdssZV6TB06aiisDwN1cX + +READ msubWq7nTVSPilWqmTzkx + + + + + + mINcNsH05D0QZDej9wl4h + + mX_x9bVx2zqKO8c2FxqgZ + + + + + + mnswinmeXuam57kXH7myI + + + + _16232574195041746640.isOpened mbHCSQc_uaLNP9Sf4Lz_n + + + + mXAYJa6osZ6HNTIEEBnr0 + + + + + + throw std maKLz6mCz5anFyVle_MtD + + + + runtime_error miAECMSxGwjxrcOKk0DII "\x5c\x78\x34\x33\x5c\x78\x36\x66\x5c\x78\x37\x35\x5c\x78\x36\x63\x5c\x78\x36\x34\x5c\x78\x32\x30\x5c\x78\x36\x65\x5c\x78\x36\x66\x5c\x78\x37\x34\x5c\x78\x32\x30\x5c\x78\x36\x66\x5c\x78\x37\x30\x5c\x78\x36\x35\x5c\x78\x36\x65\x5c\x78\x32\x30"+_3257891857586418487 mAnDeXfeHaujEzGBbrjil + mftnbgRvzOIVyL93HyyWt + + + _18062104616271777338.load mFlVjO0mLpwnCN5a1Quio + + _16232574195041746640 mmCJ670wA_VHgip7JZ1dW + + + + + mdmuaUz9iCkCckSUhcEv1 + + setDictionary mhORIPgMIfN3Fn8aCQBuU + + _18062104616271777338.dictionary,_18062104616271777338.error_correction_rate msubWq7nTVSPilWqmTzkx + + + mlqoNTA3LQoUJF6i5YDFc + + mhl3Z6oGBbP13ZxehUcg9 + + + + + + + + mKmIjE1RujJ5RSETUjqwW + + + + MarkerDetector_Impl mEMN2sRTwHcTUl7SNSw0d + + + +toStream miAECMSxGwjxrcOKk0DII + + + + + +std mpJt2kGThF7wb3VNzG38b + + + ostream &_5268611907574360399 mmCJ670wA_VHgip7JZ1dW + + const + mN0TszoCQmyzxmobsgV2H + uint64_t _5268611907573361194 mKcKHr_bTagXAK_pf8btG + + + + 13213 mINcNsH05D0QZDej9wl4h + + + + + _5268611907574360399.write mhxtTU7dvZHXCTSg8B8rx + + + mhORIPgMIfN3Fn8aCQBuU char* mAnDeXfeHaujEzGBbrjil + + + + + +&_5268611907573361194,sizeof mSa4WnWih0z4lSo9RYUGU + _5268611907573361194 muiDYQbmwLxL3PGrwWGeP + + + + + + mmCJ670wA_VHgip7JZ1dW + + mINcNsH05D0QZDej9wl4h + + + + _18062104616271777338.toStream mtbP4KQJdh36UGELfV2zq + + +_5268611907574360399 muiDYQbmwLxL3PGrwWGeP + mVOlbMaOu1U0SC2oeKIzP + + + + mDUyr1RAsHMG7u1BeTW3F + + + + + + + + mKqJtaKtNNFCDA9awnods + + + MarkerDetector_Impl mYGfQUZmV9IjKAPVrLhZl + + + fromStream mhORIPgMIfN3Fn8aCQBuU + std mU808frSKQDZnEEU3Q3s9 + + istream &_5268611907574360399 mmCJ670wA_VHgip7JZ1dW + mJkMyi0NbVRDgE__LMR_m + + + + uint64_t _5268611907573361194 mu_nOcTFwUo8r0uNE351R + + + + + + 13213 mINcNsH05D0QZDej9wl4h + + + + + _5268611907574360399.read mtbP4KQJdh36UGELfV2zq + + miAECMSxGwjxrcOKk0DII + + + char* mlqM0snvYcrWCw2_QjhQi + + &_5268611907573361194,sizeof miAECMSxGwjxrcOKk0DII + + + _5268611907573361194 mXAYJa6osZ6HNTIEEBnr0 mzf4ZxeZY8wF2XnrdYK61 + + + + mJTScPpWt8plE9Cz9fDU6 + + + + mEwOO8zzJcEkF96gfFa1e + miAECMSxGwjxrcOKk0DII + + + + + + _5268611907573361194 mtDHooAMb6ubWraYLa7pj + + 13213 muiDYQbmwLxL3PGrwWGeP + + + throw std mfx1fLYDWN4YRZNnQEsJN + runtime_error mhORIPgMIfN3Fn8aCQBuU + + + + "\x5c\x78\x34\x64\x5c\x78\x36\x31\x5c\x78\x37\x32\x5c\x78\x36\x62\x5c\x78\x36\x35\x5c\x78\x37\x32\x5c\x78\x34\x34\x5c\x78\x36\x35\x5c\x78\x37\x34\x5c\x78\x36\x35\x5c\x78\x36\x33\x5c\x78\x37\x34\x5c\x78\x36\x66\x5c\x78\x37\x32\x5c\x78\x35\x66\x5c\x78\x34\x39\x5c\x78\x36\x64\x5c\x78\x37\x30\x5c\x78\x36\x63\x5c\x78\x33\x61\x5c\x78\x33\x61\x5c\x78\x36\x36\x5c\x78\x37\x32\x5c\x78\x36\x66\x5c\x78\x36\x64\x5c\x78\x35\x33\x5c\x78\x37\x34\x5c\x78\x37\x32\x5c\x78\x36\x35\x5c\x78\x36\x31\x5c\x78\x36\x64\x5c\x78\x32\x30\x5c\x78\x36\x39\x5c\x78\x36\x65\x5c\x78\x37\x36\x5c\x78\x36\x31\x5c\x78\x36\x63\x5c\x78\x36\x39\x5c\x78\x36\x34\x5c\x78\x32\x30\x5c\x78\x37\x33\x5c\x78\x36\x39\x5c\x78\x36\x37\x5c\x78\x36\x65\x5c\x78\x36\x31\x5c\x78\x37\x34\x5c\x78\x37\x35\x5c\x78\x37\x32\x5c\x78\x36\x35" muiDYQbmwLxL3PGrwWGeP + + mJTScPpWt8plE9Cz9fDU6 + + _18062104616271777338.fromStream mhORIPgMIfN3Fn8aCQBuU + + _5268611907574360399 mhyL_M5gnmQzwyHW45MdA + mlqoNTA3LQoUJF6i5YDFc + + setDictionary mSa4WnWih0z4lSo9RYUGU + + + + _18062104616271777338.dictionary,_18062104616271777338.error_correction_rate msubWq7nTVSPilWqmTzkx + + + mlqoNTA3LQoUJF6i5YDFc + + + mDUyr1RAsHMG7u1BeTW3F + + + + mc6SGgM2Uzvo_wy5KTima + + + + MarkerDetector_Impl mfx1fLYDWN4YRZNnQEsJN + + _18048540700028965067 mReDuVelSknxaDAoDEmwT + + + std mYGfQUZmV9IjKAPVrLhZl + vector mHkLXuUOlyX2vZI7w3FQj + + cv mYGfQUZmV9IjKAPVrLhZl DMatch mBpPKNB5wfuTOV223BA2r + + + + &_14641992596943690144 mmCJ670wA_VHgip7JZ1dW mDzQQrEx5Ki0C6uDHU2cy + + + + + + + mabeHDqoCFUg5Mty5oLni + + + + miAECMSxGwjxrcOKk0DII _14641992596943690144.size mzeHK1hG1SYQMISNMWMB8 + + + + mnZ6t3BhMZ_1d7zzE72ah + + + 0 muiDYQbmwLxL3PGrwWGeP + + + + + + mGbN63kjoGx6fvYq0oiYN + + + mPdHdcAZ6XJhwf8wLtULI + + + + + mdEzmAkZNQkKD1HrLnSSo + + _3257891898253592016 myJHqW7fkn_72nVEhKeZ6 + + + + + -1 mhGXMe8LHJXydR9dMisHj + + + + + ms9iveRK8Fk_QtPMDvDcP + + + + moNuUrvhPRwgFBZS8fSa1 + + + _13303058356268144134:_14641992596943690144 mXAYJa6osZ6HNTIEEBnr0 + _3257891898253592016 mRwjoMr_aqph4iL4nu8NS + + + + + + std mdssZV6TB06aiisDwN1cX + + + + max mtbP4KQJdh36UGELfV2zq + _3257891898253592016,_13303058356268144134.queryIdx mmCJ670wA_VHgip7JZ1dW + + mJTScPpWt8plE9Cz9fDU6 + + + + + + vector mYfYoOWdsOLTDCIBT7npX + + + + + + moI11mwtxiOXpqDxK_aQL + +mBpPKNB5wfuTOV223BA2r + + _3175890141660034698 mmmC9tOGiLK6UaJr0E5vz _3257891898253592016+1,-1 muiDYQbmwLxL3PGrwWGeP + mJTScPpWt8plE9Cz9fDU6 + + + + + vector mca1GaR7Rv9qOZsisqKBB + + + + + + cv mU808frSKQDZnEEU3Q3s9 + + DMatch mBpPKNB5wfuTOV223BA2r _2844604575892364742 mmmC9tOGiLK6UaJr0E5vz + + + + +_3257891898253592016 muiDYQbmwLxL3PGrwWGeP + + mJTScPpWt8plE9Cz9fDU6 + + + + + + + mdEzmAkZNQkKD1HrLnSSo + + + + _5268611906072959276 mu_nOcTFwUo8r0uNE351R + + + 0 mhGXMe8LHJXydR9dMisHj + + + mYA_OUCZSQycbIZ5oB16m + + _17308907134902915790 mCm219F3DHVwNe_CsrCeK + + mLEx8V9d9KOGX6TpfxDP_ + + +mxdAvfSsdzliezc0uyUMk + + + + mwkUVn0D8pUxgFq_rx20G + mclhRCo4dM7MadZp5V8m6 + + + + + + &_15915593883518787333:_14641992596943690144 mycwFs63h7Mi3ggRkMEVm + mypSy3lS4LRIjRYTxVxzg + + + + + + + mJvv2tbrel2xOYjvgipUL + mSa4WnWih0z4lSo9RYUGU + + _3175890141660034698 mFyKKLtdivGGDlk8sYzsf + + + + _15915593883518787333.queryIdx mwTp2D1d4PfxNNOzzUfhS maDn6NcmB5JPmBvJglMEd + + + -1 mAnDeXfeHaujEzGBbrjil + mjbtcSgN5ZQfkGDsoYG4l + + + + + + _3175890141660034698 mY2nz8M_6jpSxQZL8EYgU + + + _15915593883518787333.queryIdx mUB1yrSrKOwldqxmCatN2 + + + + ma6VjqdfajK4BX9gkoGiD + + _5268611906072959276 mJTScPpWt8plE9Cz9fDU6 + + + + + mJOnXqKm3GBylSdRjpXAA + + + mHcxzZHoWX11H4xEjR59T + + + + + + mT_x8cqp5t43PgqNMR8gO + + mvw_MKiY3S1FcVNfJQCRT + + mtbP4KQJdh36UGELfV2zq + + + _14641992596943690144 mILaQGKCAmcKrYQNhgWUq + + _3175890141660034698 mILaQGKCAmcKrYQNhgWUq + _15915593883518787333.queryIdx mbViqhyIcr6lGWibuo3Im + + + + mrpQVzv6u8gxvho1qUlil + + .distance mtJAThUzPUAnb_DMXiQOL + + _15915593883518787333.distance mhyL_M5gnmQzwyHW45MdA + mfKhTg3wpiK_YhdQzWWcS + + + _14641992596943690144 mNDJrNgMXB1tBoFNaJO0d + _3175890141660034698 mGYpOkNIG_qSvYXBOU9Vf + _15915593883518787333.queryIdx mo8MRbS3DUX_ZOlgmUSna + + + + + + mDd5IIsnjfLI1lcygRsW3 + .queryIdx muQdV4OJL6V6gVxW6AdRy + -1 mriCvhMavpfheoLNc0eCD + + + + _3175890141660034698 mWkGo8xUdRIKgJ1DEUvvn + + + + + +_15915593883518787333.queryIdx mJtGCV8zXQjnVDVBVdvFZ + + + muQdV4OJL6V6gVxW6AdRy + _5268611906072959276 mVOlbMaOu1U0SC2oeKIzP + + _17308907134902915790 mif4ZCBkqdiqSYkR9AD0r + m_wyaFib5_cQG4j1HqokH + + mdmuaUz9iCkCckSUhcEv1 + + + + muuG2jhk4iNsA9KNmj6oA + + + + + moT0JKxDJVSALTDfSRUYM + + mnU2hwoI16_nZ7reLKJTr + + + _15915593883518787333.queryIdx mu_nOcTFwUo8r0uNE351R + -1 mxdAvfSsdzliezc0uyUMk + + + + + _17308907134902915790 mdKhcOUXVqyCMdccisL_a m_wyaFib5_cQG4j1HqokH + + + +mdmuaUz9iCkCckSUhcEv1 + + maCQ9r5fSln_CXgRXGFvO + + maCQ9r5fSln_CXgRXGFvO + + + + + + + _5268611906072959276 mUq8qfNXjDE9FPlMHvjf4 + + + + mdmuaUz9iCkCckSUhcEv1 + maCQ9r5fSln_CXgRXGFvO + + + + mWHxIxEh8g9mg3Hyipn8D + + + + + + mFsSEF_3_iD2mT6nZG9QR + +_17308907134902915790 msubWq7nTVSPilWqmTzkx + + _14641992596943690144.erase mhORIPgMIfN3Fn8aCQBuU + std maKLz6mCz5anFyVle_MtD + + + + remove_if mFsSEF_3_iD2mT6nZG9QR + + + _14641992596943690144.begin maHkatHu0Jap4oTaT5q4_ + +,_14641992596943690144.end mwTQhkbVNQHd2Xw4EA4fj + + + , mWkGo8xUdRIKgJ1DEUvvn + + mEFd2D2UDF9SIoPfQtUv6 + + + mReDuVelSknxaDAoDEmwT + + const cv mdssZV6TB06aiisDwN1cX + + + DMatch &_13303058356268144134 mmCJ670wA_VHgip7JZ1dW + + mDzQQrEx5Ki0C6uDHU2cy + + miFyHzo07syL8tsy3JLAT + + _13303058356268144134.trainIdx mHOvg7vOJH6ujsVsg3S5G -1 mQfgxxEXCA984FTu8Jz8Q + + + + _13303058356268144134.queryIdx mgAgf2KiVOzOHJDU4qKPI + + -1 mdmuaUz9iCkCckSUhcEv1 + + + + + + mhl3Z6oGBbP13ZxehUcg9 mXAYJa6osZ6HNTIEEBnr0 + + , _14641992596943690144.end maHkatHu0Jap4oTaT5q4_ + + + muiDYQbmwLxL3PGrwWGeP + + + mriCvhMavpfheoLNc0eCD + + + + + + + mgjPImSFwUcUKl9XTKqqB + + + myqrAJLu9GRcs5sFEN1xM + + + + + MarkerDetector_Impl mUCEzhGWrU8OYqcHVPlVW _14028278894506040778 mFlVjO0mLpwnCN5a1Quio + + + + + + std mdssZV6TB06aiisDwN1cX + + vector mlP1m6taP4mQVYA_j8Oxe + Marker mE4_Vrik0lveh4HNJUk1B + + +& _6528263073538749848, cv mBBHVSlvDGP5NVUfEuhuf + + Size _17190350386607761058 mzf4ZxeZY8wF2XnrdYK61 + + + mDzQQrEx5Ki0C6uDHU2cy + + + std mEMN2sRTwHcTUl7SNSw0d + + + + vector mHkLXuUOlyX2vZI7w3FQj + + std mUCEzhGWrU8OYqcHVPlVW vector mca1GaR7Rv9qOZsisqKBB + cv maKLz6mCz5anFyVle_MtD + + Point2f mYxohqgekcJ8HhaDZvWcX + + mW1YUos9eL_9NmgJuSDH7 + _13891523452203630414 mINcNsH05D0QZDej9wl4h + + + ma9rnYFEs_TUiw_WyBflg const moNuUrvhPRwgFBZS8fSa1 + + + &_13303058356268144134:_6528263073538749848 mycwFs63h7Mi3ggRkMEVm + _13891523452203630414.push_back mmmC9tOGiLK6UaJr0E5vz + + + _13303058356268144134 mycwFs63h7Mi3ggRkMEVm + + + mdmuaUz9iCkCckSUhcEv1 + + _14028278894506040778 mReDuVelSknxaDAoDEmwT + + + _13891523452203630414,_17190350386607761058 mmCJ670wA_VHgip7JZ1dW + + + mriCvhMavpfheoLNc0eCD + + + + mF9AQyKXtPTPy1zvAUpED + + size_t _13303058356268144138 myJHqW7fkn_72nVEhKeZ6 + + 0 mriCvhMavpfheoLNc0eCD + + + +_13303058356268144138 mHkLXuUOlyX2vZI7w3FQj _6528263073538749848.size mFwk30320retpLBiICndp + + + + + mxdAvfSsdzliezc0uyUMk + + + + + + _13303058356268144138 mBh4lc09qKYGXyU7FeqOv msubWq7nTVSPilWqmTzkx + + + + _6528263073538749848 mGYpOkNIG_qSvYXBOU9Vf +_13303058356268144138 mbViqhyIcr6lGWibuo3Im + + + + ma6VjqdfajK4BX9gkoGiD + + _13891523452203630414 mWkGo8xUdRIKgJ1DEUvvn + + _13303058356268144138 mo8MRbS3DUX_ZOlgmUSna + + + + + + mftnbgRvzOIVyL93HyyWt + + + + mCvAz6nTbqhvwRULRgKe4 + + + + + + + + + mQk9KGg1kmiZQnIZzbOuE + + MarkerDetector_Impl mdssZV6TB06aiisDwN1cX + + + + + _14028278894506040778 mhORIPgMIfN3Fn8aCQBuU + +std mfx1fLYDWN4YRZNnQEsJN + + + + + +vector mlP1m6taP4mQVYA_j8Oxe + + + + std myuwTFtkH1L5Be2OVY9rt + + + +vector mHkLXuUOlyX2vZI7w3FQj + + + + + cv maKLz6mCz5anFyVle_MtD + + + + + + Point2f mBpPKNB5wfuTOV223BA2r + + + + mEc9zv3P8LW8haIvtztwe + + + & _6528263073538749848, cv mBBHVSlvDGP5NVUfEuhuf + + + + Size _17190350386607761058 msubWq7nTVSPilWqmTzkx + + + + + mJkMyi0NbVRDgE__LMR_m + + + mRzhpvoeHZK7yCqqzYDDp + mhORIPgMIfN3Fn8aCQBuU + + + _6528263073538749848.size mf_hJsy06Me1epT4PRx_l + + + + mRuVXNtG32xpaNLi1hDLk + + + 0 mmCJ670wA_VHgip7JZ1dW + + mLfKYVMLDthbyvvLerNPJ + + + + + + mxdAvfSsdzliezc0uyUMk + + + + + + + + mCujczJix6jMpJcynoBiA +_14793609818754720849 mdKhcOUXVqyCMdccisL_a + + + 0 mxdAvfSsdzliezc0uyUMk + + + + moPdTa5HpJKbS1U6TqDjY + + + + size_t _13303058356268144138 mCm219F3DHVwNe_CsrCeK + + + + 0 mdmuaUz9iCkCckSUhcEv1 + + + + _13303058356268144138 mHkLXuUOlyX2vZI7w3FQj + + _14234691456098337398.size mbHCSQc_uaLNP9Sf4Lz_n + + + + mxdAvfSsdzliezc0uyUMk + + +_13303058356268144138 mcstdE8Wwpam6tUMM45Sa + + msubWq7nTVSPilWqmTzkx + + + + + mLdYY4X2b7VOjtTSnd7Hj + + + + mWHxIxEh8g9mg3Hyipn8D + miAECMSxGwjxrcOKk0DII + + + _17190350386607761058.width mYfYoOWdsOLTDCIBT7npX + _14234691456098337398 mZnfmoDANjVLDjZfzM5MR + _13303058356268144138 msdqcdg5NNrdQnc_PT1Ee .cols mzf4ZxeZY8wF2XnrdYK61 + + + _14793609818754720849 ma6VjqdfajK4BX9gkoGiD + + + + +_13303058356268144138 mftnbgRvzOIVyL93HyyWt + + + + + + + mZQqomBcB_Prq89ftbAiD + + mTFkOkggRsxkeMv25hiJW + + + + + + mINcNsH05D0QZDej9wl4h + + + + mDUyr1RAsHMG7u1BeTW3F + + + + + cv mdssZV6TB06aiisDwN1cX + + + Size _1914080660989537839 mM3tRrWbRPqPOU3G4ShKT _17190350386607761058 mdmuaUz9iCkCckSUhcEv1 + + + + + + + mhXXYzAVu3lDYyh7TkRWq + + mMGij61UZUIIYyztVz9vN + + + _13044199310297575846 mM3tRrWbRPqPOU3G4ShKT + + + + _14793609818754720849 mJTScPpWt8plE9Cz9fDU6 + + _13044199310297575846 msao8K6SR84Lu5ND7NCVt + + + + 0 mPdHdcAZ6XJhwf8wLtULI + + + _13044199310297575846 mEiOeyHRZlQujPqpgYY7u mlqM0snvYcrWCw2_QjhQi + mfKhTg3wpiK_YhdQzWWcS + + + + + + + mOcs0qqtJYmueMnfTyCFx + + + +_6633594514234248811 mRwjoMr_aqph4iL4nu8NS + + + + mYKwa_OYBeVXzRPMa_mz6 + mmmC9tOGiLK6UaJr0E5vz + + + + _14234691456098337398 mA4oXllup8K3T5dxkluRR + + _13044199310297575846 mwTp2D1d4PfxNNOzzUfhS + .cols mlqM0snvYcrWCw2_QjhQi + + +/float mtbP4KQJdh36UGELfV2zq + _1914080660989537839.width mAnDeXfeHaujEzGBbrjil + + + mftnbgRvzOIVyL93HyyWt + + + moPdTa5HpJKbS1U6TqDjY + + + + + mHXoMWKZSiZYUvqmVkLF5 + + + + &_13303058356268144134:_6528263073538749848 msubWq7nTVSPilWqmTzkx + + mF9AQyKXtPTPy1zvAUpED + + mHXoMWKZSiZYUvqmVkLF5 + + + + &_15913523031057945521:_13303058356268144134 mycwFs63h7Mi3ggRkMEVm + + + + mN0TszoCQmyzxmobsgV2H + _15913523031057945521 mt6CTIKlbWyEq7tYJENOL + + + + +_6633594514234248811 mriCvhMavpfheoLNc0eCD + + + + + maCQ9r5fSln_CXgRXGFvO + + + + + + + moI11mwtxiOXpqDxK_aQL + _134566848691226369 mCm219F3DHVwNe_CsrCeK + + + 0.5+2.5*_6633594514234248811 mhGXMe8LHJXydR9dMisHj + + + + + std mdssZV6TB06aiisDwN1cX + vector mYfYoOWdsOLTDCIBT7npX + + + + + cv myuwTFtkH1L5Be2OVY9rt + + + + Point2f mel3l7ZRXwnAEsy0Wfxj_ + + + + + _5268611907161554282 mINcNsH05D0QZDej9wl4h + + + + + mwkUVn0D8pUxgFq_rx20G + + + + + + mgxs4jaOm5WhsuDH7hsbo + &_13303058356268144134:_6528263073538749848 mXAYJa6osZ6HNTIEEBnr0 + + + + mwkUVn0D8pUxgFq_rx20G + + + myYAiLHDT3JvFKUJCC_FN &_15913523031057945521:_13303058356268144134 mlqM0snvYcrWCw2_QjhQi + mDzQQrEx5Ki0C6uDHU2cy + + + + + + _5268611907161554282.push_back mtbP4KQJdh36UGELfV2zq + + + + + + _15913523031057945521 mhyL_M5gnmQzwyHW45MdA + + + + + mJTScPpWt8plE9Cz9fDU6 + + + mJOnXqKm3GBylSdRjpXAA + cv mBBHVSlvDGP5NVUfEuhuf + + + + cornerSubPix mhORIPgMIfN3Fn8aCQBuU + + _14234691456098337398 mY2nz8M_6jpSxQZL8EYgU _13044199310297575846 mDd5IIsnjfLI1lcygRsW3 + ,_5268611907161554282,cv mpJt2kGThF7wb3VNzG38b + Size mmmC9tOGiLK6UaJr0E5vz + + _134566848691226369,_134566848691226369 mXAYJa6osZ6HNTIEEBnr0 + + + ,cv myuwTFtkH1L5Be2OVY9rt + + Size mp3H4249LtCVDCYFqQqz4 + + + + +-1,-1 muiDYQbmwLxL3PGrwWGeP + + + ,cv maKLz6mCz5anFyVle_MtD + +TermCriteria mSa4WnWih0z4lSo9RYUGU + + + + cv mpJt2kGThF7wb3VNzG38b + TermCriteria mEMN2sRTwHcTUl7SNSw0d + MAX_ITER , 4,0.5 mzf4ZxeZY8wF2XnrdYK61 + muiDYQbmwLxL3PGrwWGeP + + mdmuaUz9iCkCckSUhcEv1 + + + mP8l6554fUQhsCw2PetD2 + + + +_3175967589404451389 mCm219F3DHVwNe_CsrCeK + + + + + + 0 mVOlbMaOu1U0SC2oeKIzP + + + + moPdTa5HpJKbS1U6TqDjY + + + + mHXoMWKZSiZYUvqmVkLF5 + + + &_13303058356268144134:_6528263073538749848 mhyL_M5gnmQzwyHW45MdA + + + + ms9iveRK8Fk_QtPMDvDcP + + mgxs4jaOm5WhsuDH7hsbo + +&_15913523031057945521:_13303058356268144134 msubWq7nTVSPilWqmTzkx mfKhTg3wpiK_YhdQzWWcS + + _15913523031057945521 mdKhcOUXVqyCMdccisL_a + + + + _5268611907161554282 mWkGo8xUdRIKgJ1DEUvvn + + + _3175967589404451389 mi940TUip6nLdi0tWD33F + + + mEFd2D2UDF9SIoPfQtUv6 + + + mftnbgRvzOIVyL93HyyWt + muuG2jhk4iNsA9KNmj6oA + + + _1914080660989537839 muQdV4OJL6V6gVxW6AdRy + + +_14234691456098337398 mGYpOkNIG_qSvYXBOU9Vf + _13044199310297575846 mJtGCV8zXQjnVDVBVdvFZ + + + + .size mbHCSQc_uaLNP9Sf4Lz_n + + mPdHdcAZ6XJhwf8wLtULI + + + mCvAz6nTbqhvwRULRgKe4 + + + maCQ9r5fSln_CXgRXGFvO + + + + mhl3Z6oGBbP13ZxehUcg9 + + + + + mriCvhMavpfheoLNc0eCD + +#ifdef _3643599497981880515 +#undef mtDtuj5HWLyTAsK7Fmx4g +#undef mIM7YEc9Ba5XWDEr0m2YG +#undef miAr40ThvnnZei4PQ8nft +#undef mEc9zv3P8LW8haIvtztwe +#undef mQj7wHAa1damVYwoD46UjZpPHvzvyA2 +#undef mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y +#undef mIyXpca78p_CKHmulak4e +#undef mAVrnO9aWNRf9b3dALx0J +#undef mI_QuD605u2H3qQFyuTju +#undef mhMsdnRaOV1FZ69nEgvbs +#undef muRWS4RqXt1RDg1intuX3MkjrSgf2o4 +#undef mHOvg7vOJH6ujsVsg3S5G +#undef mfge932GrgApRFyCExy_M +#undef mIzujDpHjrUPsW3ssOAji +#undef mM0eyBFMShg9qdQPSMqiz +#undef mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT +#undef mC854TxsErP91YgtWBjLs +#undef mwxm9pz2KjGAhBIIfFMf4 +#undef me9YsE5_K5dlCgWRVtztQ +#undef mCAzyIDtopeLXRxFfI0EK +#undef mabeHDqoCFUg5Mty5oLni +#undef m_owRLEm0gIJ4StPRwTkZ +#undef mBJ7M0ikk98KhD4Oi32wB +#undef mbtXL8AfsmYGQ1waevjwS +#undef moNuUrvhPRwgFBZS8fSa1 +#undef mSD7jHYN8mOif4_CBtIg6 +#undef mLhy8e0peljv3075Jx0N4 +#undef mtDHooAMb6ubWraYLa7pj +#undef mAQWugjGggd1dm4Esoytv +#undef mOcs0qqtJYmueMnfTyCFx +#undef mhORIPgMIfN3Fn8aCQBuU +#undef mPF9YW010VzHVkbdsdOMJgq7D81z3gH +#undef mHIh6WyQKJh1ZKme1nslP +#undef mo03bPDhF7WKTf8ndM1Bk +#undef mFyKKLtdivGGDlk8sYzsf +#undef mMinTurqhjOTBoJcyTuRpllwDXFTRab +#undef mYxohqgekcJ8HhaDZvWcX +#undef mJkMyi0NbVRDgE__LMR_m +#undef mwBOm3LXJ8FMsqTgQKZ6O +#undef m_Gim03zcA2esaeteCftKMhV2X3oFiR +#undef mhl3Z6oGBbP13ZxehUcg9 +#undef mdkQcL_ccA3dE51c_fq0e +#undef mv1ijGQAKacWqWAusY8nc +#undef mCqWliO9r5qeuU4xIw2kK +#undef mZeHXgILeDH93lObH9TjZ9sjRzIIBMF +#undef mF8CPQI5IssWjwlV2CXVE +#undef m_YnlLsKBlim0LDKxc0Xy +#undef moT0JKxDJVSALTDfSRUYM +#undef mOk7NgrdfVmJx9axvYv9F +#undef mfySD3GO3N8Vw4agWXnxR +#undef mwoUu824QThZXd8c3IKpk +#undef mCnIg_Afe_CAU6Bb6OxXH +#undef mFK5JCwqLjSVNjbuFv1Xz +#undef mTAavMivNX5WuUrRQXoEf +#undef mAtZroqlrY5Hmm_G3pFca +#undef mCQaCcJleVmF11nXRNijz +#undef mWHxIxEh8g9mg3Hyipn8D +#undef mCAk2bmH5F7oeetankJLO +#undef mH52So0EeYsEZDduDH5e4qGZvbPX6fz +#undef mA4oXllup8K3T5dxkluRR +#undef mXh8R2TW8u4BE0GHtpbVz +#undef mReDuVelSknxaDAoDEmwT +#undef mE_Ow4Xh61sHZuYT9u_vp +#undef mKqJtaKtNNFCDA9awnods +#undef mNAgAegAkh3aostDDex0p +#undef mjjNAUwZAzilKpyI1Dk6r +#undef mrYYGY_ATzXkS3kXEPpEg +#undef moE42zHNBVjnlCdllZAkS +#undef mJTScPpWt8plE9Cz9fDU6 +#undef mFwk30320retpLBiICndp +#undef mPdHdcAZ6XJhwf8wLtULI +#undef mHAbGd4HvG2QvOxZcs3lT +#undef mc6SGgM2Uzvo_wy5KTima +#undef mvfKgFvXHh0Jqv_PZxbka +#undef mclhRCo4dM7MadZp5V8m6 +#undef mUgRzGHHwu8B0HUYWcJfg +#undef mtL59O4fTIGPJKdcQHvhB +#undef mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC +#undef mxD9VicPg3JzxB0Nq4Uo1xLfNkXirAD +#undef muESrr63SaH81rmeBWzRi +#undef mE4_Vrik0lveh4HNJUk1B +#undef mCvAz6nTbqhvwRULRgKe4 +#undef mm3iTU9Va924R0kb0bFj1 +#undef mnSkEvR4SbDwQxj23xB1M +#undef mK02Cexqsx6vNaoTzun_D +#undef mlKtR21FV5abL2Mmi4l1T +#undef mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU +#undef mhgllqTSj8yCumOJiOB_SNOZi1jZpHa +#undef mce_8CnsU6ESSZfDxaV3C +#undef mINcNsH05D0QZDej9wl4h +#undef mSQwieae_zm87QxGSkqhw +#undef mlP1m6taP4mQVYA_j8Oxe +#undef mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF +#undef mlqoNTA3LQoUJF6i5YDFc +#undef mYM4ze6K0DiGvfExY0uu0 +#undef mDd5IIsnjfLI1lcygRsW3 +#undef msRrpu3bfxgN_CQlh5kGb +#undef maKLz6mCz5anFyVle_MtD +#undef m_DXxPIyOoo082vGXUpjcjCP9GYwO5X +#undef mbvotPuLfQMMkHkrWczyy +#undef mCpxQXTS3AV0wU8W7TGY0 +#undef mCOuCt3mN6pV7VrSR351Y +#undef mnZ6t3BhMZ_1d7zzE72ah +#undef mnAk2iR9Su1JlXNU__70t +#undef mWUoD50tT9HFGBNQCsjUC +#undef mFrnvKb629IAbveEQOTJk +#undef mpHTdkvfapV5_Igrm_XSs +#undef mjE2s1jSu76TqssWv5OkpQyTNcXDW0j +#undef m_7GcuKeh99wm21PzmE3XY0ABoZNB_w +#undef mndAbF8Mhqs6wYK8Ew3E6 +#undef mJSI8Lfa53eTFnQ8sZxQl +#undef mMGij61UZUIIYyztVz9vN +#undef mRrVhT0WkQauAZEUJHKOK +#undef mgfxr297Vj2D89efCcdCK +#undef mpJt2kGThF7wb3VNzG38b +#undef mZHJfF8VODcHrGq0YEwM_ +#undef mypSy3lS4LRIjRYTxVxzg +#undef mgN2NPegMIWZaSlArqSpX +#undef mHZ0KiNSj0hY4k5601_yW +#undef mTQiPILYbCv0nYwQtndF8 +#undef mP8l6554fUQhsCw2PetD2 +#undef mp3H4249LtCVDCYFqQqz4 +#undef mMqLg7J_GrCMFwMZsIhbs +#undef mZnfmoDANjVLDjZfzM5MR +#undef mpDI48gcBVmyAktanjCOQ +#undef mfKhTg3wpiK_YhdQzWWcS +#undef mFKRUYDiDlNmwfGKdBg2S +#undef mjc_6rRmys9smvg_opA48 +#undef mKb2gquqaqcZhKKuABYQAQTKDfCzCv8 +#undef mVgd0sC5KIFeGa4mcMXm9 +#undef msdqcdg5NNrdQnc_PT1Ee +#undef mu3VfwjYyEXmsa3FxHdyz +#undef mEUOZPFJPicZ9AQx6_FEx +#undef meSFhtslMYeRECKXZrMQ8rKH8kdvfsC +#undef mgQ_wngzoaArigUsebwJ5 +#undef mnqZGwZqTTi1dekKxujAE +#undef mexiex6yQ4W2cwOKYmh9Kok982mCBo0 +#undef msMfR3R5kzP8SqAQ3DWTq +#undef muxyK0XEbbiarSy_y8QSe +#undef mhxVrs8TRVT7m4DD0qJSy +#undef mLOAPVN3DUqvZfrHEsp7F +#undef mCALzjQ0bwpDnngl_oSsi +#undef mPjc1ei1txxv19TBbzbvk +#undef mf_hJsy06Me1epT4PRx_l +#undef m_NWV9acHYMEPlYLCkf5F +#undef mCuBtAqzIu5X7282ZWyHMjsFupyWd7i +#undef mVHGLK1C5RNdKdXzDgMZU +#undef mhKXOgA6gWk8walTiLP2RlqyfDmKe1e +#undef mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a +#undef mUvhkm5O6wWaFaksW3gGB +#undef mIwaKux_FnDqG9TKWI9sf +#undef miAECMSxGwjxrcOKk0DII +#undef myo_tabD5NOdQw_HDUeAl +#undef mj7rzLUFNjZZ8TQ9LzphN +#undef mXkfygpbRUCrOfJA4ktlP +#undef mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u +#undef mB3kG5fis1WUHfqjDpcgw +#undef mwnRQJQKy9VbzznJbM76_ +#undef myqrAJLu9GRcs5sFEN1xM +#undef mvW7MwxFgHE1jUFn6bpuP +#undef mjbtcSgN5ZQfkGDsoYG4l +#undef mJ9ZKhf2JTQ6b_phI67L4 +#undef mRzhpvoeHZK7yCqqzYDDp +#undef mgWtxscBTuWBkK7X3fJ_M +#undef meOIEIGNtns3N9UkZHp_p +#undef mYB93ieg1KMHexoJXsKQO +#undef mnzbRa6WXDfLtEhMMu8uf +#undef mi940TUip6nLdi0tWD33F +#undef mN0TszoCQmyzxmobsgV2H +#undef mikiSyOnVry6pvQ1Ds28H +#undef mjVigZhPz5SJG76mcwBBH +#undef mh5Oneq9KX80ZFd7dCoKK +#undef mUh25fI232n1nZuNP2DcY +#undef mNMDyj9J1Nt8auTKwp8ze +#undef mfx1fLYDWN4YRZNnQEsJN +#undef mErel9ajJN1agpA_k4bOG +#undef mT_x8cqp5t43PgqNMR8gO +#undef mzo2b_NWVHgZakDiMHmV12I4pTxTTDh +#undef mZQqomBcB_Prq89ftbAiD +#undef mzqBtnG8Ja0w84lba1GCT +#undef mYYWXe0GsOK9y3tuaI0XM8wApbmutU0 +#undef mA7GovY8jPZMrXdPcttrfcvZCc5QYs1 +#undef msubWq7nTVSPilWqmTzkx +#undef muQdV4OJL6V6gVxW6AdRy +#undef mzeHK1hG1SYQMISNMWMB8 +#undef mXyxJEKR2vQDAiXVkkZ96 +#undef mTjppsgNpY1Pjyv5Z_zMr +#undef mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW +#undef mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU +#undef mdNWJa6f_e7wadzG60ejq +#undef mBuRRlPSkgfIqW4MkJEkn +#undef mel3l7ZRXwnAEsy0Wfxj_ +#undef mm9xpbYUQ152i_zNBGUZu +#undef mUB1yrSrKOwldqxmCatN2 +#undef mxMl9vPEiIZkGZuxtm_RI +#undef mBBHVSlvDGP5NVUfEuhuf +#undef mP2fo6VtM4ySlx6m268_j +#undef mt6CTIKlbWyEq7tYJENOL +#undef mUrLXSL7g29oB1gxfN8O0 +#undef mqHHu9OC8XdQm9Yh7V7x0 +#undef mcqTciDcDgSbPPY9iuwhB +#undef muh3toWhBpay0OfyCHmRI +#undef ma9rnYFEs_TUiw_WyBflg +#undef mKui3FcBrQ5fUw3SS2JBl +#undef mIMikP4zsPvXTvXr7Rfnr +#undef mhyL_M5gnmQzwyHW45MdA +#undef mhgVj3QiKBmvoTbS8WYEn +#undef mdLKGc6TH1B4fmpMEcP4V +#undef mpMWr23OozoNFIk9M3JRl +#undef mNDJrNgMXB1tBoFNaJO0d +#undef mKcKHr_bTagXAK_pf8btG +#undef mnECjbnhLknZie3Z5iHP2 +#undef mTFkOkggRsxkeMv25hiJW +#undef mSuHweZ8NLqp3TniIO9nc +#undef mCm219F3DHVwNe_CsrCeK +#undef mXUi6ZMBLLcoMCxEzieWB +#undef mrRUZLmQTdeC3HO0hVmGH +#undef mW1ds9XwNwevT5B2b3j8B +#undef mlJqcdUT0sl1_64qaqDwc +#undef mQk9KGg1kmiZQnIZzbOuE +#undef mVRbVdVjFvNmKzGv4WiNp +#undef mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt +#undef mbG1GEmOdh2dXkJZ42sXo +#undef mjxPa00ei9qkuuQmiGB3C +#undef mSDkw9ayb_9gGdMv3ViWL +#undef mElbPhFy9PzMYpwK0rJM72HTzRPloIw +#undef mgor9wB6mrVARR8vJt7rC +#undef mH9ypXNXQET4Yi7K20Jh29E84Mwri1d +#undef mrm8jC9SczExaamJBF8OL +#undef mYONm1FLAyaMuB1zKpzHD +#undef m_BNZbnU2Y1bOBnnPOF0b +#undef mWA_ETdQ9hsfQKo10V6Ed +#undef mMXwD61a3ZsfucFBja1D_ +#undef mep87jMrgQZcK1mXjlt_w +#undef mmCJ670wA_VHgip7JZ1dW +#undef mifrRvzkyTJgS5ZnlEWNT +#undef mVuIjgANzXjC9nUwtjYpEMMKzGy7cEj +#undef mt0bWs8kxCzTnBdtR9vKu +#undef mfNhxMALMjy2jMKPPP3pN +#undef mfi_VmSWr30C6e1Og_9nDolWgyPyTBP +#undef mtPtbM6hNfOIkqlx661ci +#undef mbHCSQc_uaLNP9Sf4Lz_n +#undef mwkUVn0D8pUxgFq_rx20G +#undef mOEGA4b6sqebQZ8Uv15A2 +#undef mKwBF6wdaXmwZg6eVpHR2 +#undef mnkTvEdpCXelpIHLLqQno +#undef mLfKYVMLDthbyvvLerNPJ +#undef mDjDVHrQ1nua2LsKX9HSc +#undef maOczvhF_v9OTsK70ZZut +#undef mFlVjO0mLpwnCN5a1Quio +#undef mKmIjE1RujJ5RSETUjqwW +#undef mHbmZNNhradVwUtDZ5U7B +#undef mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN +#undef maCQ9r5fSln_CXgRXGFvO +#undef mqHOA0Vf8azkugKZoQT2g +#undef mIkhxhgSNMt_JUZR7ce1U +#undef mn7NaVKR8Eys8MRznQhqq +#undef mwTQhkbVNQHd2Xw4EA4fj +#undef mgAgf2KiVOzOHJDU4qKPI +#undef mUtcrfgjMX2yuzlJWU7ae +#undef msFedzwaZ2kcbRyPxAwvYLedNBp9XR1 +#undef migVyykpmr2io3DNlFdHK +#undef mdF98bHO7yrxGJn0aQZVK +#undef mRawsH1LNxMcHXhyroWR7 +#undef mqENAtmVRtspFcCyFxQkl +#undef msFQPbyubcQTkvTYpFFPL +#undef mGyGrvv4NjvJFmxY5zFqS +#undef mt0GBkUzL9v7leCB9JJCC +#undef mlqM0snvYcrWCw2_QjhQi +#undef mtggfblAKFVUli3PxtdvW +#undef mJke9dzVx7gMdakG5cgU_ +#undef meZ135JJTidHY5m2MSApS +#undef mhXXYzAVu3lDYyh7TkRWq +#undef mJOnXqKm3GBylSdRjpXAA +#undef mriCvhMavpfheoLNc0eCD +#undef mJWlrLOowGXzksrQ1iOpo +#undef mnt0Yxwh2kXjuvEydiY6Z +#undef mEz1qIDbyJp0Jb730lPO1 +#undef mr45_AiDx2WPxM5kKJ73c +#undef mM7GnshIhlJuqxxDdvNQ9 +#undef mDzQQrEx5Ki0C6uDHU2cy +#undef mukpDKZCMfw2TrxqBczvn +#undef muKP5B7qysoQRrYrwu_aG +#undef mzcT8teQAcAtdQGMnR4j__bo0O7W6fh +#undef mnU2hwoI16_nZ7reLKJTr +#undef mIqkiLoOdpjYrPavNSkO3 +#undef moPdTa5HpJKbS1U6TqDjY +#undef mb7CDbA8OAKKL51zp5Kp2 +#undef mPvJelqEXJke3tsTVDKaA +#undef mArVNsRyxIBuRhpRuviXmuMgA4HFptj +#undef mLdYY4X2b7VOjtTSnd7Hj +#undef mdssZV6TB06aiisDwN1cX +#undef mT1nRBXOOPTe1uInaQg48 +#undef mQDLRy0PKsddZ3xq0mn3V +#undef mmhvewuTDMRQuh4yozZj0 +#undef mwQUfI7G4pBH6IJQiBjmU +#undef mvAxy99EwaX0EkXFRf6SN +#undef mECamByxBqjGyTShbPlRQ +#undef mYwsOAvDOXneTzOST0d5c +#undef mgxs4jaOm5WhsuDH7hsbo +#undef mnlCUtQ6kn1Qc7HkEzE0c +#undef mThelntXiwCutIvyMhNsD +#undef mFMxB_7Xv8pds76G1KO8P +#undef mM3tRrWbRPqPOU3G4ShKT +#undef mwTp2D1d4PfxNNOzzUfhS +#undef mGYpOkNIG_qSvYXBOU9Vf +#undef maSZLm7xL0jGtxyrdwaul +#undef muOzaq9SXefX6wOasanyX +#undef mevyCL_5kjUx7NbD67ju0rSs5KRucsR +#undef mOwM0Kfjt44STnd1SP93u +#undef mVVBTZX2L35xKLlbqB8u4 +#undef mLC2F6mTDlCPm4Amdj66bcsfP08vka4 +#undef mpi20hzA7RnQ_cRlycwva +#undef mkyaUNysRlFi3wOJaaFye +#undef mdWkXjuaPd4Se0r0SdY1e +#undef mYA_OUCZSQycbIZ5oB16m +#undef mZVOYp2JAGvUM7UPbzd3Q +#undef mkGHGzUDDVqHIjIdYGe6S +#undef mPJvcMzH2GoPEPAArs6CO +#undef mQwlYb2fiOk1ogUVAZU22 +#undef mPlk6hpBhStcHkX9pfoTY +#undef mwuimZUNEQYuguDYpIp15llEoOqkXc0 +#undef mt0J2cgGrQp2ucvKFkwuOILDyrA8QJM +#undef mDUyr1RAsHMG7u1BeTW3F +#undef mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7 +#undef mGmn6AwhPqDzvkxFmEeXf +#undef mEFd2D2UDF9SIoPfQtUv6 +#undef mJRcV3UxOoHUziTla6CTItAztGL9WSZ +#undef mcvC2D_94pblXXCjjwhbKRwRZdXBrpg +#undef mQaMmAoZTrzB9rh95SV_SNzHqc0isDC +#undef mKAy3YZbvi464n5g9TLhbuXIqHPaeqv +#undef mRltbJjpZ8AzImbP6r6M4 +#undef mPrvhmoEgzU_ThNhPmGUb +#undef miGFoFUQX5urgUZ1Rewwt +#undef mBpPKNB5wfuTOV223BA2r +#undef mYPzKChOwisp1u2IoCgxk +#undef mxIhhpr2Lkr3NxxDHw1vq +#undef mglDNKH5ah89GptW6H4Cu +#undef mgkSwnYHQivQIpeAwgr20 +#undef mCBPKKFCRSbvDkZsS_B45 +#undef mcstdE8Wwpam6tUMM45Sa +#undef mC_m9rmwsKDO6tF3NGSKw +#undef mr0l01irlQTHxEjA5eunteQkeoLuBQY +#undef mTTOC6Wz4GS45ua7oKbWEmBZpWCWLbr +#undef mOR5gj7K3yTraJVOrvmKy +#undef mzf4ZxeZY8wF2XnrdYK61 +#undef miTVnDZI0mihWq9STK4vZ +#undef mmAbmKM2jnErQzGL0hU87 +#undef mYsjCP2nXqW2Jls3JAUkc +#undef mxQewHEnT8PTNQcVKCqL9 +#undef mYfpOohym5jydVBxgDUop +#undef maoHwm5lyecyelmN95sur +#undef mMRNM5hfPBWFjYCspldu3 +#undef mqwYu0y4oTPCnfXbylThX +#undef mG9O2bX6GrjZ7A14g4o0R +#undef mLplHCs9IECRrk3AL90fE +#undef mN1cOqoznikSSj4MMYyFX +#undef my42VNapWQSG36GDaLRZU +#undef mGxw9hY3riKhnwFZ5jcqN +#undef mX2089XJEUghT4WdpeqIpdVl5urfw9e +#undef mNHO_HqPPuJ0s1xmA3Hyp +#undef mBh4lc09qKYGXyU7FeqOv +#undef mtbP4KQJdh36UGELfV2zq +#undef mfurntceIvF3j4__Qp6L5 +#undef mv50Xfpo4ITZHLXGtKNlu +#undef mEGd5SkTeDLeSnWPvzGk3 +#undef miFyHzo07syL8tsy3JLAT +#undef mEMN2sRTwHcTUl7SNSw0d +#undef mqm5corqEX8t35Uu6nBYm_yWWsarIow +#undef mmu72Hys1y28eLiXc2AAu_ewAGX_SGw +#undef mC5oDJ0qE1gW_qsx3g1mu +#undef mxL2jX9CFTtSnMCJoJ1anRskFISM7ye +#undef mE51_Yx1e52Gg6LtJn8Ft +#undef mlkXvCGjzNE_N7vszwePKcZNchffiZF +#undef muuG2jhk4iNsA9KNmj6oA +#undef m_6hetAMDOSYN9CmiL4W7 +#undef mgSkXUgcRjYGUB2o3shqJ +#undef mufZyaMJ62rgFtcDkgqf_5OhhyLV_dz +#undef mAnDeXfeHaujEzGBbrjil +#undef mrYTPN06XEG4I2Q8GwVal +#undef m_j6ZkbEfLCgUqtaolYTp +#undef md8eYFrUH5ZCVnYz5HXJs +#undef mq_LX9xWjqEZjC_8nIQQB +#undef mHkLXuUOlyX2vZI7w3FQj +#undef mIyKKzozGjE84ROdV4z79 +#undef mca1GaR7Rv9qOZsisqKBB +#undef mTna5ZWhTRHGhmpdDhP8Q +#undef muE9dUeTdzrXFfj8JjJHsYH_fISmi_r +#undef mopvqiLosQusnLb5T1cPQ +#undef mfXSqvRpqFIhzf0yTtohv +#undef mw5UR8oGzCkqj2vUYmwOhK4QF0sXpUa +#undef mWB0Y3YknsbsRFnNAcGvV +#undef moRHJd8MnQc4OOt6sDvUk +#undef mqEAvVDOCXqrrwrTRByrM +#undef mbYMUxVFybbviIFqRhN2f +#undef mEs6URNF5M0ltIuqxZLOvZ6JUSiM86Q +#undef mftnbgRvzOIVyL93HyyWt +#undef mb_mniVMqcXJMFkJcXnTV +#undef mnIgag5XDMc1HAJdYJSOnPrbWBffgTI +#undef mILaQGKCAmcKrYQNhgWUq +#undef ms9iveRK8Fk_QtPMDvDcP +#undef mLx62v15Gc0EOGYi5W96J +#undef maISPbNJKXWB2QqsuuExM +#undef mYKwa_OYBeVXzRPMa_mz6 +#undef myuwTFtkH1L5Be2OVY9rt +#undef mmmC9tOGiLK6UaJr0E5vz +#undef maZplRnE_IUwmU_xzu3NekpUHRmaUSP +#undef mRpzyAUUkieNHbskgKP0AofElml4apw +#undef mxdAvfSsdzliezc0uyUMk +#undef mICILgDpdCTDSJqQAn06L +#undef mdDEjFb9QPcGyAxk8oT5M +#undef mE5GmVndUe3w4VVob7TEw +#undef mNQatzTrxcdXGxcIUXU8h +#undef mILr1bxfFRdMH70QJkaPL +#undef mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN +#undef mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz +#undef mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz +#undef mu0qe2vnLpegnyYWkJiID +#undef mHcxzZHoWX11H4xEjR59T +#undef mX_x9bVx2zqKO8c2FxqgZ +#undef mKqJbq4fPTw28Ilr7bzpA +#undef mu5MgGYXZDetF61l00p1M +#undef muKLilOLbFZ3yJM00gLINUymjA4CZq_ +#undef mlxKATcGFZZXuYzEVZko1 +#undef mhnMl9nmNNK1ubSXXRkWs +#undef mAwnIBmzoGA1R_JK770kK +#undef mwcRCcU6S0ahJKT269YrZSchpTbqC8A +#undef mEiOeyHRZlQujPqpgYY7u +#undef mv4kxLDTrK8Y14srOeMs9 +#undef mif4ZCBkqdiqSYkR9AD0r +#undef mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E +#undef mu_nOcTFwUo8r0uNE351R +#undef mUPTRsc2WCtijDSKQungDsRrIFUGnz1 +#undef mshTvqIeJnktjfxvTh_Q17geiWCXNRC +#undef mquhIKppt3a65sc068Kvt +#undef mY2nz8M_6jpSxQZL8EYgU +#undef moejXze8_C6TCxb2bIzgq +#undef mSlNeIB2kCkOFZLLZbZvl +#undef mYw4kKgGPg9_7sRPuoSD2B2Tl35GJX3 +#undef mH1xQMRmYb0Y4RDp2hARz +#undef mlujXFTq8HgFCDqLu7dpu +#undef mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW +#undef mwzVPTpaJAiRC6bZKMfQX +#undef mKpq3GwvJxRduE5RsGgGP +#undef mkuXAnWhKAEZ7UQwHldfZw6MZuPCbu2 +#undef mvw_MKiY3S1FcVNfJQCRT +#undef m_bMsemALspVgRNyYoh4QNv5h7J6TCa +#undef mIYvQtGxrUTK9jCV0wgjB +#undef mpoy16fiv_eugwBU4NxPwSY0pkiHptx +#undef mGkUuomrp7ufvC8H_J8ZB +#undef mwu5s8ye7pYEdPIYXjU5h +#undef mbndM1iNeSBZryqPzzxpU +#undef mA9OyoOle98msK0BnFc8I +#undef mLsmsKBxetQnHulsmKvKGZrZv3OKajL +#undef mQu7TMP4YfBcqf0WCzN18 +#undef mJvv2tbrel2xOYjvgipUL +#undef mNEkKASvjK_HgII9jzEu6 +#undef mbFGY3HJrKnP_L6H3dMsA +#undef m_lICnZ0bJGmuMACmMVcA +#undef m_Bc574zvmsa5bmM8Ay7H +#undef mNhNSN2gx5KERe8tfdmgu +#undef mbsrpR8qe_bXg_8iiy7_QWHFwDBK3Ps +#undef mhDkJpX31vSJRGCWwJgDF +#undef mf4h8kYb28ybDtqub3aw3HtQXgCqXKS +#undef mgjPImSFwUcUKl9XTKqqB +#undef myYAiLHDT3JvFKUJCC_FN +#undef myFE4ZIOynNe4GHuzkHmk +#undef mxD0ASUiBIk9J4KLYW_eX +#undef meWm4MhzbcJwavtoh469w +#undef mpaH8vob0MFQfWtEu0gpW +#undef mo8MRbS3DUX_ZOlgmUSna +#undef myYaYWcsrnLoe6SxorDYt +#undef mEDa32iTjVIlpXzu_8bXW +#undef mGbN63kjoGx6fvYq0oiYN +#undef mqQspPZKCoa6LP0Jj0qH2 +#undef mzPPQ5Tm31T6ToJuCly5i +#undef mUFzn4yJGA8c9qnEcb9dH +#undef mMNJIG0z6TLGgbjrhllmy +#undef mwwJvnj2j3yLmklxxOEJQ +#undef mVOlbMaOu1U0SC2oeKIzP +#undef mHaUGkpJ3E2hPS8TahoVd +#undef mDWRa2VXHJyGtXnU3Z9De +#undef m_wyaFib5_cQG4j1HqokH +#undef mE0JnyzA4LAd5tJboIPVe +#undef mKzXNxKoc8d_JaqSCmnt5 +#undef mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY +#undef myCKVyjNuW6E_Fp3y6x2x +#undef mdKhcOUXVqyCMdccisL_a +#undef mgRihfujs8Yyx1O6Z75ze +#undef mPBSejyyYBZX7KoLjIvqq +#undef mow1IjdflpN81ICD702rC +#undef mVPyhnVeODFpKcj5PAnUM +#undef myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF +#undef mEzFcmvX0IX3FOucgCcVF +#undef mbQuioGdvAG5jcbGdIlbv +#undef mi0dc2wlXgNoHf9VPli9f +#undef mnNakURRgCUtkCBzEeIbT +#undef mS2LGTpbZiAMEweak007k +#undef mZk2lUQMDVDhOLQdg9s92 +#undef mc03ciJcqzEcDCvFZREOoKestkbXulB +#undef maHkatHu0Jap4oTaT5q4_ +#undef mcJvl68QD2UYT9DPOREOj +#undef mD8VAS4XY9Vf6fdJqnluZ +#undef mHgo4JTEAdFhAHz3buc5U +#undef mJI2h44hAoDYrHnLdxJ9jbIgiWRiz8s +#undef mGuK55c17XqU0IVL5INTz +#undef mUq8qfNXjDE9FPlMHvjf4 +#undef mU8SToe5QpPWgY0z9QAcm +#undef mhGXMe8LHJXydR9dMisHj +#undef mlkEZnzYCXAgDnYDi5up3 +#undef miFg9XqPeEmQjjY9dOISI +#undef mneGB1iZsOWGhJroSY5fV +#undef mrpQVzv6u8gxvho1qUlil +#undef mhlQDh1wF6VsRTHY9MXvo +#undef mEZrtAN7pSZl5y4oEHd38 +#undef mUCEzhGWrU8OYqcHVPlVW +#undef mihBlyb7pwidO496a5_p1 +#undef mw_6Ab4pR3RtOt7wvMnqF +#undef mtnsDyAXJojPFvMiilyGbFo63qTJSV_ +#undef mrzvE9vOXIlwaUYsJynGX +#undef mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI +#undef mnswinmeXuam57kXH7myI +#undef mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R +#undef mF9AQyKXtPTPy1zvAUpED +#undef msao8K6SR84Lu5ND7NCVt +#undef mRwjoMr_aqph4iL4nu8NS +#undef mfFGohhJTv_x4m7UMdlWF +#undef mEmzu5ycY6iORBuT83fJe +#undef mt3VEObKOLfcodk2q6Hb4 +#undef maDn6NcmB5JPmBvJglMEd +#undef mhpoAZakkKCTBIsnDg7v3 +#undef mdEzmAkZNQkKD1HrLnSSo +#undef mKdH1o6rFuMJ1Fl0PA_sn +#undef mZiUSTfWjbMiMsmxNY2q9 +#undef mWokjWH0MHqyBOx4j0Oac +#undef mO3OYAsYlFzrizsYt__9m +#undef mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu +#undef mtvEQgcnwdOR4zAMwLHDb +#undef mWkGo8xUdRIKgJ1DEUvvn +#undef maB_pNl4zuODt3oqXg9EB +#undef mCujczJix6jMpJcynoBiA +#undef mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie +#undef mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF +#undef mxNiL7NRse0iP2D2VgJvE +#undef mKcyQhGKewGQ8D80ltPKd +#undef mAcwJn9Fm7cgTYOF5KC6H +#undef mbViqhyIcr6lGWibuo3Im +#undef mW1YUos9eL_9NmgJuSDH7 +#undef mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH +#undef mEwOO8zzJcEkF96gfFa1e +#undef mK5OxIt23gZzSiTA8trU8 +#undef mSovB5T1QsQHo_5C08NNM +#undef mm3KIQTUMZkPidze1WHnH +#undef mYfYoOWdsOLTDCIBT7npX +#undef mLEx8V9d9KOGX6TpfxDP_ +#undef mfBNQ_3zW9r0ekYxjcYs6 +#undef mIt7rZ26ebLuaPjnQsvmi +#undef mAB2YZQWllAMMhMcSXYQGJ6zEaONDDT +#undef mfJA9NVd6FBgGhRSkkhhs +#undef mSx88YARryA674S7RpNKv +#undef maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8 +#undef minXN1_7si2azFOae4puK +#undef mYGfQUZmV9IjKAPVrLhZl +#undef mG7mr0Iq8BCEeADSwrCoW +#undef mtFjgCt4NTpjOcEST1puq +#undef mRuVXNtG32xpaNLi1hDLk +#undef mYPq_LjN7ad6AVi4Iwwhx +#undef mSBH4REv5nn8iXIXWLqFa +#undef mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr +#undef mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv +#undef mbVacJ38Njfe_9kvqyl6v +#undef mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj +#undef muiDYQbmwLxL3PGrwWGeP +#undef mxjRBOqzfKYNpief2KWEu +#undef mC7CcuPGpz81aizhogiZL +#undef moI11mwtxiOXpqDxK_aQL +#undef mf3l8ay5y_EjkAsZg8mUs +#undef mDx7kMxPPgzO4EUIw_BnI +#undef myJHqW7fkn_72nVEhKeZ6 +#undef mk9FUg_FZy9ugg8Rqf3jY +#undef mvvjvpVVXY9qkY9G6I2UZ +#undef mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox +#undef mJtGCV8zXQjnVDVBVdvFZ +#undef mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2 +#undef mGXmXMs8LhHsVpd3vA7qq +#undef mRHNkLPwUSnx20pmLgrTq +#undef mQfgxxEXCA984FTu8Jz8Q +#undef mW0z8FqRbcMOOqrwq1TRC +#undef mhGemuVhKwpkxrzvad1IFvExNIEs7Ak +#undef mUwTrZwI1VfAXDN69k3UA +#undef mRrGWRfoKK0rGG_g5N_ah +#undef mndDt3huhmUYGZC1vQmOq +#undef mhxtTU7dvZHXCTSg8B8rx +#undef mdmuaUz9iCkCckSUhcEv1 +#undef mOymGuaDUIEo4ESm5VpCR +#undef mo7mKuzaX2h9vw2rEj5qh +#undef mdbRZP7cWFYlUcaGRMsKc +#undef mtJAThUzPUAnb_DMXiQOL +#undef mYI2nkSxgJHf1pY1PttV1 +#undef mLBxgVrVeq7bTUcDGJqNH +#undef mGDvPrxv8kCxNPwud9IqM +#undef miFbFMaHNYmE7ZhdtdD1I +#undef mMcZ82Suei3klnF_x2Lcx +#undef mFsSEF_3_iD2mT6nZG9QR +#undef mKbtq8OHrv8CI8FhvE4XG +#undef mkIOpFxp9pqNBAq8rhDn1 +#undef ma84ph1Q5xfgaPalqi72x +#undef mztFjkqY05BHqxhJraeJTl0p2s3heFu +#undef mm2qioZxIvP_11cqVcoVX +#undef mSa4WnWih0z4lSo9RYUGU +#undef mXRH4Jm901JGMftiW3Yi4 +#undef mtBaSZn4xtaMpMhvfebM_ +#undef mycwFs63h7Mi3ggRkMEVm +#undef mU808frSKQDZnEEU3Q3s9 +#undef ma43zKzGwyDT5C3mNdj6s +#undef myyhXEjkyqbh66A1Qwu0O +#undef mXAYJa6osZ6HNTIEEBnr0 +#undef ma6VjqdfajK4BX9gkoGiD +#undef mij4fDpzx7A1fAEkEKDEN +#undef mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G +#undef mCytfckU7SmdEgj6kDXVCjNq_lj0sfn +#undef mmB6x9VkGrq_qpFtMKL7A +#undef mfQTptx1DXC7MJP5Cfk8m +#undef mIwyzOHEkeXgErUDD0EEp +#undef m_e_PmiIjNUGQEwSJbBF8 +#undef mgM8ScCmoJ3qXwMzVOzZc +#undef mQnt4GgeXMPy1qcLwCadlcgZL0S7aML +#undef mHXoMWKZSiZYUvqmVkLF5 +#undef mcznTYeCGOAygtXXAPYS_ +#undef mECcJc0jrNRWKGTvkEzeA +#endif + +#ifdef _3643599497981880515 +#undef mECcJc0jrNRWKGTvkEzeA +#undef mdNWJa6f_e7wadzG60ejq +#undef mAVrnO9aWNRf9b3dALx0J +#undef mwuimZUNEQYuguDYpIp15llEoOqkXc0 +#undef mFwk30320retpLBiICndp +#undef mqwYu0y4oTPCnfXbylThX +#undef m_Bc574zvmsa5bmM8Ay7H +#undef mm3iTU9Va924R0kb0bFj1 +#undef mdssZV6TB06aiisDwN1cX +#undef mgQ_wngzoaArigUsebwJ5 +#undef mJkMyi0NbVRDgE__LMR_m +#undef mgor9wB6mrVARR8vJt7rC +#undef mYB93ieg1KMHexoJXsKQO +#undef mCQaCcJleVmF11nXRNijz +#undef mjc_6rRmys9smvg_opA48 +#undef mDd5IIsnjfLI1lcygRsW3 +#undef mvvjvpVVXY9qkY9G6I2UZ +#undef mwkUVn0D8pUxgFq_rx20G +#undef mpDI48gcBVmyAktanjCOQ +#undef mifrRvzkyTJgS5ZnlEWNT +#undef mt0bWs8kxCzTnBdtR9vKu +#undef mW0z8FqRbcMOOqrwq1TRC +#undef mMGij61UZUIIYyztVz9vN +#undef mwwJvnj2j3yLmklxxOEJQ +#undef mndAbF8Mhqs6wYK8Ew3E6 +#undef mt6CTIKlbWyEq7tYJENOL +#undef mm9xpbYUQ152i_zNBGUZu +#undef mlkEZnzYCXAgDnYDi5up3 +#undef meSFhtslMYeRECKXZrMQ8rKH8kdvfsC +#undef mihBlyb7pwidO496a5_p1 +#undef mX_x9bVx2zqKO8c2FxqgZ +#undef mcvC2D_94pblXXCjjwhbKRwRZdXBrpg +#undef md8eYFrUH5ZCVnYz5HXJs +#undef meZ135JJTidHY5m2MSApS +#undef mpi20hzA7RnQ_cRlycwva +#undef mnlCUtQ6kn1Qc7HkEzE0c +#undef mxD0ASUiBIk9J4KLYW_eX +#undef mndDt3huhmUYGZC1vQmOq +#undef mWB0Y3YknsbsRFnNAcGvV +#undef mdkQcL_ccA3dE51c_fq0e +#undef miFyHzo07syL8tsy3JLAT +#undef mGYpOkNIG_qSvYXBOU9Vf +#undef mEMN2sRTwHcTUl7SNSw0d +#undef miFbFMaHNYmE7ZhdtdD1I +#undef mPlk6hpBhStcHkX9pfoTY +#undef mkGHGzUDDVqHIjIdYGe6S +#undef mGDvPrxv8kCxNPwud9IqM +#undef mDzQQrEx5Ki0C6uDHU2cy +#undef my42VNapWQSG36GDaLRZU +#undef mglDNKH5ah89GptW6H4Cu +#undef mEDa32iTjVIlpXzu_8bXW +#undef mvW7MwxFgHE1jUFn6bpuP +#undef m_wyaFib5_cQG4j1HqokH +#undef mQk9KGg1kmiZQnIZzbOuE +#undef mZQqomBcB_Prq89ftbAiD +#undef mcznTYeCGOAygtXXAPYS_ +#undef mrpQVzv6u8gxvho1qUlil +#undef mhORIPgMIfN3Fn8aCQBuU +#undef mhgVj3QiKBmvoTbS8WYEn +#undef mxjRBOqzfKYNpief2KWEu +#undef mnswinmeXuam57kXH7myI +#undef mHAbGd4HvG2QvOxZcs3lT +#undef mCuBtAqzIu5X7282ZWyHMjsFupyWd7i +#undef mX2089XJEUghT4WdpeqIpdVl5urfw9e +#undef mKbtq8OHrv8CI8FhvE4XG +#undef me9YsE5_K5dlCgWRVtztQ +#undef myJHqW7fkn_72nVEhKeZ6 +#undef mdKhcOUXVqyCMdccisL_a +#undef mReDuVelSknxaDAoDEmwT +#undef mmB6x9VkGrq_qpFtMKL7A +#undef mwxm9pz2KjGAhBIIfFMf4 +#undef mB3kG5fis1WUHfqjDpcgw +#undef mA4oXllup8K3T5dxkluRR +#undef mxMl9vPEiIZkGZuxtm_RI +#undef mf_hJsy06Me1epT4PRx_l +#undef mMXwD61a3ZsfucFBja1D_ +#undef mLEx8V9d9KOGX6TpfxDP_ +#undef mSovB5T1QsQHo_5C08NNM +#undef mUFzn4yJGA8c9qnEcb9dH +#undef mfXSqvRpqFIhzf0yTtohv +#undef mlKtR21FV5abL2Mmi4l1T +#undef mF8CPQI5IssWjwlV2CXVE +#undef m_BNZbnU2Y1bOBnnPOF0b +#undef mdbRZP7cWFYlUcaGRMsKc +#undef mFMxB_7Xv8pds76G1KO8P +#undef mZVOYp2JAGvUM7UPbzd3Q +#undef mCm219F3DHVwNe_CsrCeK +#undef mGbN63kjoGx6fvYq0oiYN +#undef mUtcrfgjMX2yuzlJWU7ae +#undef mu5MgGYXZDetF61l00p1M +#undef mpMBFPEerAbCZmlkKlVh_N5JqyDGaBN +#undef mo7mKuzaX2h9vw2rEj5qh +#undef mf4h8kYb28ybDtqub3aw3HtQXgCqXKS +#undef mhXXYzAVu3lDYyh7TkRWq +#undef m_e_PmiIjNUGQEwSJbBF8 +#undef mgxs4jaOm5WhsuDH7hsbo +#undef mnU2hwoI16_nZ7reLKJTr +#undef msMfR3R5kzP8SqAQ3DWTq +#undef mIYvQtGxrUTK9jCV0wgjB +#undef mpK6pxKC4ZXHIzSanBPacwWmlP7OzCz +#undef mjVigZhPz5SJG76mcwBBH +#undef mnkTvEdpCXelpIHLLqQno +#undef mftnbgRvzOIVyL93HyyWt +#undef mypSy3lS4LRIjRYTxVxzg +#undef mOEGA4b6sqebQZ8Uv15A2 +#undef maKLz6mCz5anFyVle_MtD +#undef mwoUu824QThZXd8c3IKpk +#undef mjZvNSly8dRBzZWtVgAvmKEoP5XXUaT +#undef mkIOpFxp9pqNBAq8rhDn1 +#undef mLx62v15Gc0EOGYi5W96J +#undef mDUyr1RAsHMG7u1BeTW3F +#undef mJvv2tbrel2xOYjvgipUL +#undef mLUq8aGfwkTdnzQeNJ5jI_xlRY0CnTH +#undef mK02Cexqsx6vNaoTzun_D +#undef muKP5B7qysoQRrYrwu_aG +#undef mAj3V8fNuZa0zcT9SrcGtpUv4tleVbU +#undef mY2nz8M_6jpSxQZL8EYgU +#undef mqQspPZKCoa6LP0Jj0qH2 +#undef mAtZroqlrY5Hmm_G3pFca +#undef mF143YfMMbFl_Z9MaIdMK0RKDi2Kttj +#undef mNaa6ujtHJ_ALdoCJCd9Rs9bJsl9CA2 +#undef mJOnXqKm3GBylSdRjpXAA +#undef mTTOC6Wz4GS45ua7oKbWEmBZpWCWLbr +#undef mdmuaUz9iCkCckSUhcEv1 +#undef mArVNsRyxIBuRhpRuviXmuMgA4HFptj +#undef mjjNAUwZAzilKpyI1Dk6r +#undef mNHO_HqPPuJ0s1xmA3Hyp +#undef mHkLXuUOlyX2vZI7w3FQj +#undef mP2fo6VtM4ySlx6m268_j +#undef mtbP4KQJdh36UGELfV2zq +#undef mt0J2cgGrQp2ucvKFkwuOILDyrA8QJM +#undef mvI29UffPi_yJdDV3Vdm6w3QHqlu4_u +#undef mPBSejyyYBZX7KoLjIvqq +#undef mOcs0qqtJYmueMnfTyCFx +#undef mzqBtnG8Ja0w84lba1GCT +#undef mKqJbq4fPTw28Ilr7bzpA +#undef mUh25fI232n1nZuNP2DcY +#undef mMinTurqhjOTBoJcyTuRpllwDXFTRab +#undef mbFGY3HJrKnP_L6H3dMsA +#undef mikiSyOnVry6pvQ1Ds28H +#undef mKmIjE1RujJ5RSETUjqwW +#undef mOUkN_e0mvAXFRqMX_1zcW7MgjGhp1y +#undef mYPzKChOwisp1u2IoCgxk +#undef mWHxIxEh8g9mg3Hyipn8D +#undef maOczvhF_v9OTsK70ZZut +#undef m_6hetAMDOSYN9CmiL4W7 +#undef mFKRUYDiDlNmwfGKdBg2S +#undef mCALzjQ0bwpDnngl_oSsi +#undef mshTvqIeJnktjfxvTh_Q17geiWCXNRC +#undef m_NWV9acHYMEPlYLCkf5F +#undef ms9iveRK8Fk_QtPMDvDcP +#undef mEGd5SkTeDLeSnWPvzGk3 +#undef mFyKKLtdivGGDlk8sYzsf +#undef mwB_tR_srO0AlQhW1UaDy4Mdgah73Ie +#undef mG7mr0Iq8BCEeADSwrCoW +#undef mgWtxscBTuWBkK7X3fJ_M +#undef mfNhxMALMjy2jMKPPP3pN +#undef mH9ypXNXQET4Yi7K20Jh29E84Mwri1d +#undef mfi_VmSWr30C6e1Og_9nDolWgyPyTBP +#undef mbG1GEmOdh2dXkJZ42sXo +#undef mYwsOAvDOXneTzOST0d5c +#undef m_j6ZkbEfLCgUqtaolYTp +#undef mJI2h44hAoDYrHnLdxJ9jbIgiWRiz8s +#undef mrYTPN06XEG4I2Q8GwVal +#undef mw_6Ab4pR3RtOt7wvMnqF +#undef mlqoNTA3LQoUJF6i5YDFc +#undef mj7rzLUFNjZZ8TQ9LzphN +#undef mHbM_KF_gXQWZUU1d0ujVAErQ9WIsE7 +#undef mXyxJEKR2vQDAiXVkkZ96 +#undef mbsrpR8qe_bXg_8iiy7_QWHFwDBK3Ps +#undef mYsjCP2nXqW2Jls3JAUkc +#undef myFE4ZIOynNe4GHuzkHmk +#undef mlkXvCGjzNE_N7vszwePKcZNchffiZF +#undef miFg9XqPeEmQjjY9dOISI +#undef muQdV4OJL6V6gVxW6AdRy +#undef mBBHVSlvDGP5NVUfEuhuf +#undef mYxohqgekcJ8HhaDZvWcX +#undef mRrGWRfoKK0rGG_g5N_ah +#undef mS2LGTpbZiAMEweak007k +#undef mhxtTU7dvZHXCTSg8B8rx +#undef mfySD3GO3N8Vw4agWXnxR +#undef mjbtcSgN5ZQfkGDsoYG4l +#undef mQu7TMP4YfBcqf0WCzN18 +#undef mow1IjdflpN81ICD702rC +#undef mZk2lUQMDVDhOLQdg9s92 +#undef mdv5HkIEce_oVJ1EZRdFAVtmBv8s70E +#undef mPJvcMzH2GoPEPAArs6CO +#undef mce_8CnsU6ESSZfDxaV3C +#undef mEz1qIDbyJp0Jb730lPO1 +#undef mLsmsKBxetQnHulsmKvKGZrZv3OKajL +#undef mKdH1o6rFuMJ1Fl0PA_sn +#undef mEZrtAN7pSZl5y4oEHd38 +#undef m_lICnZ0bJGmuMACmMVcA +#undef mu_nOcTFwUo8r0uNE351R +#undef mRltbJjpZ8AzImbP6r6M4 +#undef mVp3Hbc3BvDdBF2TbdhJSYsWvSPIb1a +#undef mhGemuVhKwpkxrzvad1IFvExNIEs7Ak +#undef mUPTRsc2WCtijDSKQungDsRrIFUGnz1 +#undef mUwTrZwI1VfAXDN69k3UA +#undef mCOuCt3mN6pV7VrSR351Y +#undef mdDEjFb9QPcGyAxk8oT5M +#undef mfurntceIvF3j4__Qp6L5 +#undef mEwOO8zzJcEkF96gfFa1e +#undef mgSkXUgcRjYGUB2o3shqJ +#undef mAcwJn9Fm7cgTYOF5KC6H +#undef mXh8R2TW8u4BE0GHtpbVz +#undef mGmn6AwhPqDzvkxFmEeXf +#undef mJ9ZKhf2JTQ6b_phI67L4 +#undef myuwTFtkH1L5Be2OVY9rt +#undef mzcT8teQAcAtdQGMnR4j__bo0O7W6fh +#undef mRpzyAUUkieNHbskgKP0AofElml4apw +#undef mmu72Hys1y28eLiXc2AAu_ewAGX_SGw +#undef mBh4lc09qKYGXyU7FeqOv +#undef mQXaQXjy6_0omD3OJNtnmqqjGEvfmVW +#undef mKcyQhGKewGQ8D80ltPKd +#undef mwzVPTpaJAiRC6bZKMfQX +#undef mZHJfF8VODcHrGq0YEwM_ +#undef mQfgxxEXCA984FTu8Jz8Q +#undef mO3OYAsYlFzrizsYt__9m +#undef mt0GBkUzL9v7leCB9JJCC +#undef mtDtuj5HWLyTAsK7Fmx4g +#undef mLplHCs9IECRrk3AL90fE +#undef mVOlbMaOu1U0SC2oeKIzP +#undef mnAk2iR9Su1JlXNU__70t +#undef mUB1yrSrKOwldqxmCatN2 +#undef mZeHXgILeDH93lObH9TjZ9sjRzIIBMF +#undef mfJA9NVd6FBgGhRSkkhhs +#undef mD8VAS4XY9Vf6fdJqnluZ +#undef mU808frSKQDZnEEU3Q3s9 +#undef mvfKgFvXHh0Jqv_PZxbka +#undef mxNiL7NRse0iP2D2VgJvE +#undef miGFoFUQX5urgUZ1Rewwt +#undef mqENAtmVRtspFcCyFxQkl +#undef mquhIKppt3a65sc068Kvt +#undef mwcRCcU6S0ahJKT269YrZSchpTbqC8A +#undef mmmC9tOGiLK6UaJr0E5vz +#undef m_DXxPIyOoo082vGXUpjcjCP9GYwO5X +#undef mOwM0Kfjt44STnd1SP93u +#undef mOR5gj7K3yTraJVOrvmKy +#undef mTna5ZWhTRHGhmpdDhP8Q +#undef mE_Ow4Xh61sHZuYT9u_vp +#undef mCytfckU7SmdEgj6kDXVCjNq_lj0sfn +#undef mp3H4249LtCVDCYFqQqz4 +#undef mIkhxhgSNMt_JUZR7ce1U +#undef mgjPImSFwUcUKl9XTKqqB +#undef moE42zHNBVjnlCdllZAkS +#undef mc6SGgM2Uzvo_wy5KTima +#undef mVRbVdVjFvNmKzGv4WiNp +#undef mmAbmKM2jnErQzGL0hU87 +#undef mSDkw9ayb_9gGdMv3ViWL +#undef mqHOA0Vf8azkugKZoQT2g +#undef mpaH8vob0MFQfWtEu0gpW +#undef mnzbRa6WXDfLtEhMMu8uf +#undef mBJ7M0ikk98KhD4Oi32wB +#undef mxIhhpr2Lkr3NxxDHw1vq +#undef ma6VjqdfajK4BX9gkoGiD +#undef mkyaUNysRlFi3wOJaaFye +#undef mEUOZPFJPicZ9AQx6_FEx +#undef mqm5corqEX8t35Uu6nBYm_yWWsarIow +#undef mHcxzZHoWX11H4xEjR59T +#undef mIwaKux_FnDqG9TKWI9sf +#undef mGuK55c17XqU0IVL5INTz +#undef mC5oDJ0qE1gW_qsx3g1mu +#undef mnZ6t3BhMZ_1d7zzE72ah +#undef myo_tabD5NOdQw_HDUeAl +#undef mtFjgCt4NTpjOcEST1puq +#undef mtggfblAKFVUli3PxtdvW +#undef mtPtbM6hNfOIkqlx661ci +#undef mtnsDyAXJojPFvMiilyGbFo63qTJSV_ +#undef mLdYY4X2b7VOjtTSnd7Hj +#undef msubWq7nTVSPilWqmTzkx +#undef mfKhTg3wpiK_YhdQzWWcS +#undef mcqTciDcDgSbPPY9iuwhB +#undef mf3l8ay5y_EjkAsZg8mUs +#undef moT0JKxDJVSALTDfSRUYM +#undef mtL59O4fTIGPJKdcQHvhB +#undef mwTp2D1d4PfxNNOzzUfhS +#undef mAQWugjGggd1dm4Esoytv +#undef mSD7jHYN8mOif4_CBtIg6 +#undef mm3KIQTUMZkPidze1WHnH +#undef mU8SToe5QpPWgY0z9QAcm +#undef mNAgAegAkh3aostDDex0p +#undef muuG2jhk4iNsA9KNmj6oA +#undef mc03ciJcqzEcDCvFZREOoKestkbXulB +#undef mF9AQyKXtPTPy1zvAUpED +#undef mElbPhFy9PzMYpwK0rJM72HTzRPloIw +#undef mfQTptx1DXC7MJP5Cfk8m +#undef mnt0Yxwh2kXjuvEydiY6Z +#undef mLAyuz6ew2kcuDM4WDYVh_gZKvgSujI +#undef mhgllqTSj8yCumOJiOB_SNOZi1jZpHa +#undef mKwBF6wdaXmwZg6eVpHR2 +#undef mzf4ZxeZY8wF2XnrdYK61 +#undef mINcNsH05D0QZDej9wl4h +#undef mMcZ82Suei3klnF_x2Lcx +#undef mPjc1ei1txxv19TBbzbvk +#undef m_owRLEm0gIJ4StPRwTkZ +#undef mr45_AiDx2WPxM5kKJ73c +#undef mYI2nkSxgJHf1pY1PttV1 +#undef mBpPKNB5wfuTOV223BA2r +#undef mW1ds9XwNwevT5B2b3j8B +#undef mrRUZLmQTdeC3HO0hVmGH +#undef mtDHooAMb6ubWraYLa7pj +#undef maEFLZezqY5U6Z1uodgwOrhnCjJ0sF8 +#undef mRwjoMr_aqph4iL4nu8NS +#undef mC7CcuPGpz81aizhogiZL +#undef m_Gim03zcA2esaeteCftKMhV2X3oFiR +#undef mv1ijGQAKacWqWAusY8nc +#undef mTQiPILYbCv0nYwQtndF8 +#undef mHOvg7vOJH6ujsVsg3S5G +#undef maHkatHu0Jap4oTaT5q4_ +#undef muE9dUeTdzrXFfj8JjJHsYH_fISmi_r +#undef minXN1_7si2azFOae4puK +#undef mxQewHEnT8PTNQcVKCqL9 +#undef mLBxgVrVeq7bTUcDGJqNH +#undef maDn6NcmB5JPmBvJglMEd +#undef mCujczJix6jMpJcynoBiA +#undef mEFd2D2UDF9SIoPfQtUv6 +#undef mDx7kMxPPgzO4EUIw_BnI +#undef maB_pNl4zuODt3oqXg9EB +#undef mzo2b_NWVHgZakDiMHmV12I4pTxTTDh +#undef mOymGuaDUIEo4ESm5VpCR +#undef mWA_ETdQ9hsfQKo10V6Ed +#undef mhyL_M5gnmQzwyHW45MdA +#undef myCKVyjNuW6E_Fp3y6x2x +#undef mgwL6is5QhemFfW7wm_rZ_nRAPsXgJv +#undef mRzhpvoeHZK7yCqqzYDDp +#undef mzeHK1hG1SYQMISNMWMB8 +#undef mrzvE9vOXIlwaUYsJynGX +#undef mSx88YARryA674S7RpNKv +#undef mjMOaWmMPr8ItcnEZ6T4c_g9OqFiQNu +#undef mGkUuomrp7ufvC8H_J8ZB +#undef mC_m9rmwsKDO6tF3NGSKw +#undef mKpq3GwvJxRduE5RsGgGP +#undef mCAzyIDtopeLXRxFfI0EK +#undef mopvqiLosQusnLb5T1cPQ +#undef mbvotPuLfQMMkHkrWczyy +#undef mFK5JCwqLjSVNjbuFv1Xz +#undef mPGFDLw9gfyEeUaqQx6LAHaoPtc1orW +#undef mECamByxBqjGyTShbPlRQ +#undef mEzFcmvX0IX3FOucgCcVF +#undef mdF98bHO7yrxGJn0aQZVK +#undef mzPPQ5Tm31T6ToJuCly5i +#undef mpJt2kGThF7wb3VNzG38b +#undef mclhRCo4dM7MadZp5V8m6 +#undef mJTScPpWt8plE9Cz9fDU6 +#undef moI11mwtxiOXpqDxK_aQL +#undef mHbmZNNhradVwUtDZ5U7B +#undef mLfKYVMLDthbyvvLerNPJ +#undef mQaMmAoZTrzB9rh95SV_SNzHqc0isDC +#undef mIqkiLoOdpjYrPavNSkO3 +#undef mfBNQ_3zW9r0ekYxjcYs6 +#undef mij4fDpzx7A1fAEkEKDEN +#undef mIyKKzozGjE84ROdV4z79 +#undef mILaQGKCAmcKrYQNhgWUq +#undef mi940TUip6nLdi0tWD33F +#undef mhnMl9nmNNK1ubSXXRkWs +#undef mWokjWH0MHqyBOx4j0Oac +#undef mVVBTZX2L35xKLlbqB8u4 +#undef mbndM1iNeSBZryqPzzxpU +#undef moRHJd8MnQc4OOt6sDvUk +#undef mYKwa_OYBeVXzRPMa_mz6 +#undef mE5GmVndUe3w4VVob7TEw +#undef mCAk2bmH5F7oeetankJLO +#undef mqjuzmrNEJwUFkGqO6vrPRYH4JUn_Nr +#undef mKcKHr_bTagXAK_pf8btG +#undef mYPq_LjN7ad6AVi4Iwwhx +#undef mvAxy99EwaX0EkXFRf6SN +#undef mfFGohhJTv_x4m7UMdlWF +#undef mwnRQJQKy9VbzznJbM76_ +#undef mDjDVHrQ1nua2LsKX9HSc +#undef mErel9ajJN1agpA_k4bOG +#undef mSQwieae_zm87QxGSkqhw +#undef moNuUrvhPRwgFBZS8fSa1 +#undef mQDLRy0PKsddZ3xq0mn3V +#undef mYXI6akWhgUvZT8jo8YhkqYsAMP1jkY +#undef mN1cOqoznikSSj4MMYyFX +#undef mJSI8Lfa53eTFnQ8sZxQl +#undef mbViqhyIcr6lGWibuo3Im +#undef mA9OyoOle98msK0BnFc8I +#undef mMulv_XQGj3NCbH3ZzsnjY5lTur4XhC +#undef mca1GaR7Rv9qOZsisqKBB +#undef mqEAvVDOCXqrrwrTRByrM +#undef mk9FUg_FZy9ugg8Rqf3jY +#undef mEs6URNF5M0ltIuqxZLOvZ6JUSiM86Q +#undef mel3l7ZRXwnAEsy0Wfxj_ +#undef mlujXFTq8HgFCDqLu7dpu +#undef maoHwm5lyecyelmN95sur +#undef mKzXNxKoc8d_JaqSCmnt5 +#undef mM7GnshIhlJuqxxDdvNQ9 +#undef mgkSwnYHQivQIpeAwgr20 +#undef maISPbNJKXWB2QqsuuExM +#undef muiDYQbmwLxL3PGrwWGeP +#undef mK5OxIt23gZzSiTA8trU8 +#undef mYM4ze6K0DiGvfExY0uu0 +#undef mIyXpca78p_CKHmulak4e +#undef mh5Oneq9KX80ZFd7dCoKK +#undef mfEJVRQBs4hneAPP3gYA3JbeGJQ1p1G +#undef mGXmXMs8LhHsVpd3vA7qq +#undef myYjgiQKBm8Uh4y6ADl8EaOnTRM7ARF +#undef mTFkOkggRsxkeMv25hiJW +#undef mRawsH1LNxMcHXhyroWR7 +#undef mvw_MKiY3S1FcVNfJQCRT +#undef mhKXOgA6gWk8walTiLP2RlqyfDmKe1e +#undef mr0l01irlQTHxEjA5eunteQkeoLuBQY +#undef mMqLg7J_GrCMFwMZsIhbs +#undef mwBOm3LXJ8FMsqTgQKZ6O +#undef mRuVXNtG32xpaNLi1hDLk +#undef mmhvewuTDMRQuh4yozZj0 +#undef muxyK0XEbbiarSy_y8QSe +#undef mriCvhMavpfheoLNc0eCD +#undef mw5UR8oGzCkqj2vUYmwOhK4QF0sXpUa +#undef mUq8qfNXjDE9FPlMHvjf4 +#undef miAECMSxGwjxrcOKk0DII +#undef mA7GovY8jPZMrXdPcttrfcvZCc5QYs1 +#undef mo03bPDhF7WKTf8ndM1Bk +#undef mpoy16fiv_eugwBU4NxPwSY0pkiHptx +#undef mVHGLK1C5RNdKdXzDgMZU +#undef mHXoMWKZSiZYUvqmVkLF5 +#undef mufZyaMJ62rgFtcDkgqf_5OhhyLV_dz +#undef mHIh6WyQKJh1ZKme1nslP +#undef mUCEzhGWrU8OYqcHVPlVW +#undef mtJAThUzPUAnb_DMXiQOL +#undef mFlVjO0mLpwnCN5a1Quio +#undef mCQUcD5Wqq0xYCpbFRRNO0RmR88JAJN +#undef mQj7wHAa1damVYwoD46UjZpPHvzvyA2 +#undef mGyGrvv4NjvJFmxY5zFqS +#undef mPF9YW010VzHVkbdsdOMJgq7D81z3gH +#undef mPrvhmoEgzU_ThNhPmGUb +#undef mnqZGwZqTTi1dekKxujAE +#undef myqrAJLu9GRcs5sFEN1xM +#undef mM3tRrWbRPqPOU3G4ShKT +#undef mPvJelqEXJke3tsTVDKaA +#undef mYfpOohym5jydVBxgDUop +#undef mYYWXe0GsOK9y3tuaI0XM8wApbmutU0 +#undef mt3VEObKOLfcodk2q6Hb4 +#undef mTjppsgNpY1Pjyv5Z_zMr +#undef mH52So0EeYsEZDduDH5e4qGZvbPX6fz +#undef mI_QuD605u2H3qQFyuTju +#undef mAnDeXfeHaujEzGBbrjil +#undef mSa4WnWih0z4lSo9RYUGU +#undef mCvAz6nTbqhvwRULRgKe4 +#undef mLC2F6mTDlCPm4Amdj66bcsfP08vka4 +#undef mHZ0KiNSj0hY4k5601_yW +#undef mQwlYb2fiOk1ogUVAZU22 +#undef mnIgag5XDMc1HAJdYJSOnPrbWBffgTI +#undef mQi7J_kk5ajjMTmbc_84aBzXX_jf4VF +#undef mb_mniVMqcXJMFkJcXnTV +#undef mNhNSN2gx5KERe8tfdmgu +#undef mRrVhT0WkQauAZEUJHKOK +#undef msao8K6SR84Lu5ND7NCVt +#undef mJtGCV8zXQjnVDVBVdvFZ +#undef mEc9zv3P8LW8haIvtztwe +#undef miTVnDZI0mihWq9STK4vZ +#undef mLhy8e0peljv3075Jx0N4 +#undef mhl3Z6oGBbP13ZxehUcg9 +#undef mxL2jX9CFTtSnMCJoJ1anRskFISM7ye +#undef mVPyhnVeODFpKcj5PAnUM +#undef mnECjbnhLknZie3Z5iHP2 +#undef mm2qioZxIvP_11cqVcoVX +#undef mXUi6ZMBLLcoMCxEzieWB +#undef mCqWliO9r5qeuU4xIw2kK +#undef mrYYGY_ATzXkS3kXEPpEg +#undef mrm8jC9SczExaamJBF8OL +#undef mUvhkm5O6wWaFaksW3gGB +#undef mHgo4JTEAdFhAHz3buc5U +#undef mQnt4GgeXMPy1qcLwCadlcgZL0S7aML +#undef mYA_OUCZSQycbIZ5oB16m +#undef mE0JnyzA4LAd5tJboIPVe +#undef mKAy3YZbvi464n5g9TLhbuXIqHPaeqv +#undef mVuIjgANzXjC9nUwtjYpEMMKzGy7cEj +#undef mtBaSZn4xtaMpMhvfebM_ +#undef mSlNeIB2kCkOFZLLZbZvl +#undef mZnfmoDANjVLDjZfzM5MR +#undef maZplRnE_IUwmU_xzu3NekpUHRmaUSP +#undef mXkfygpbRUCrOfJA4ktlP +#undef mnSkEvR4SbDwQxj23xB1M +#undef mq_LX9xWjqEZjC_8nIQQB +#undef mYGfQUZmV9IjKAPVrLhZl +#undef mlxKATcGFZZXuYzEVZko1 +#undef maSZLm7xL0jGtxyrdwaul +#undef mgM8ScCmoJ3qXwMzVOzZc +#undef mAB2YZQWllAMMhMcSXYQGJ6zEaONDDT +#undef m_bMsemALspVgRNyYoh4QNv5h7J6TCa +#undef mlqM0snvYcrWCw2_QjhQi +#undef mFsSEF_3_iD2mT6nZG9QR +#undef moejXze8_C6TCxb2bIzgq +#undef muRWS4RqXt1RDg1intuX3MkjrSgf2o4 +#undef mVgd0sC5KIFeGa4mcMXm9 +#undef mwTQhkbVNQHd2Xw4EA4fj +#undef myYAiLHDT3JvFKUJCC_FN +#undef mztFjkqY05BHqxhJraeJTl0p2s3heFu +#undef mOk7NgrdfVmJx9axvYv9F +#undef mevyCL_5kjUx7NbD67ju0rSs5KRucsR +#undef mE51_Yx1e52Gg6LtJn8Ft +#undef meOIEIGNtns3N9UkZHp_p +#undef mGxw9hY3riKhnwFZ5jcqN +#undef mdEzmAkZNQkKD1HrLnSSo +#undef mu0qe2vnLpegnyYWkJiID +#undef mYfYoOWdsOLTDCIBT7npX +#undef msdqcdg5NNrdQnc_PT1Ee +#undef mxD9VicPg3JzxB0Nq4Uo1xLfNkXirAD +#undef mG9O2bX6GrjZ7A14g4o0R +#undef mdLKGc6TH1B4fmpMEcP4V +#undef mgfxr297Vj2D89efCcdCK +#undef mE4_Vrik0lveh4HNJUk1B +#undef mAwnIBmzoGA1R_JK770kK +#undef mDWRa2VXHJyGtXnU3Z9De +#undef mgAgf2KiVOzOHJDU4qKPI +#undef mCBPKKFCRSbvDkZsS_B45 +#undef mmCJ670wA_VHgip7JZ1dW +#undef myyhXEjkyqbh66A1Qwu0O +#undef mNQatzTrxcdXGxcIUXU8h +#undef mThelntXiwCutIvyMhNsD +#undef mcstdE8Wwpam6tUMM45Sa +#undef mv50Xfpo4ITZHLXGtKNlu +#undef mLOAPVN3DUqvZfrHEsp7F +#undef mJWlrLOowGXzksrQ1iOpo +#undef mb7CDbA8OAKKL51zp5Kp2 +#undef mbHCSQc_uaLNP9Sf4Lz_n +#undef moPdTa5HpJKbS1U6TqDjY +#undef mxdAvfSsdzliezc0uyUMk +#undef maCQ9r5fSln_CXgRXGFvO +#undef mU9VP3QJ9gv29uJkz1XdfyWFueNU0ox +#undef mPdHdcAZ6XJhwf8wLtULI +#undef m_7GcuKeh99wm21PzmE3XY0ABoZNB_w +#undef mbYMUxVFybbviIFqRhN2f +#undef mEiOeyHRZlQujPqpgYY7u +#undef mCpxQXTS3AV0wU8W7TGY0 +#undef ma9rnYFEs_TUiw_WyBflg +#undef mlJqcdUT0sl1_64qaqDwc +#undef miAr40ThvnnZei4PQ8nft +#undef mpHTdkvfapV5_Igrm_XSs +#undef mTAavMivNX5WuUrRQXoEf +#undef mMRNM5hfPBWFjYCspldu3 +#undef mW1YUos9eL_9NmgJuSDH7 +#undef mXFwkqyd3dyZLs7ksk6mRRA9u5tIcrz +#undef mRHNkLPwUSnx20pmLgrTq +#undef muESrr63SaH81rmeBWzRi +#undef myYaYWcsrnLoe6SxorDYt +#undef mn7NaVKR8Eys8MRznQhqq +#undef mILr1bxfFRdMH70QJkaPL +#undef mgN2NPegMIWZaSlArqSpX +#undef mpMWr23OozoNFIk9M3JRl +#undef mwsJhmv6J4dy4fPTvAhKZtmyi6b9kGU +#undef mUgRzGHHwu8B0HUYWcJfg +#undef mUrLXSL7g29oB1gxfN8O0 +#undef mhxVrs8TRVT7m4DD0qJSy +#undef mIMikP4zsPvXTvXr7Rfnr +#undef msRrpu3bfxgN_CQlh5kGb +#undef mbVacJ38Njfe_9kvqyl6v +#undef mIt7rZ26ebLuaPjnQsvmi +#undef mif4ZCBkqdiqSYkR9AD0r +#undef mM0eyBFMShg9qdQPSMqiz +#undef muh3toWhBpay0OfyCHmRI +#undef mIzujDpHjrUPsW3ssOAji +#undef mZiUSTfWjbMiMsmxNY2q9 +#undef mIM7YEc9Ba5XWDEr0m2YG +#undef mhlQDh1wF6VsRTHY9MXvo +#undef mycwFs63h7Mi3ggRkMEVm +#undef mi0dc2wlXgNoHf9VPli9f +#undef ma43zKzGwyDT5C3mNdj6s +#undef mEmzu5ycY6iORBuT83fJe +#undef mdWkXjuaPd4Se0r0SdY1e +#undef mcJvl68QD2UYT9DPOREOj +#undef mexiex6yQ4W2cwOKYmh9Kok982mCBo0 +#undef mJke9dzVx7gMdakG5cgU_ +#undef mT_x8cqp5t43PgqNMR8gO +#undef mbtXL8AfsmYGQ1waevjwS +#undef mfge932GrgApRFyCExy_M +#undef mCnIg_Afe_CAU6Bb6OxXH +#undef mNMDyj9J1Nt8auTKwp8ze +#undef mo8MRbS3DUX_ZOlgmUSna +#undef mfx1fLYDWN4YRZNnQEsJN +#undef mjE2s1jSu76TqssWv5OkpQyTNcXDW0j +#undef mep87jMrgQZcK1mXjlt_w +#undef mSBH4REv5nn8iXIXWLqFa +#undef mv4kxLDTrK8Y14srOeMs9 +#undef mjxPa00ei9qkuuQmiGB3C +#undef m_YnlLsKBlim0LDKxc0Xy +#undef msFQPbyubcQTkvTYpFFPL +#undef msFedzwaZ2kcbRyPxAwvYLedNBp9XR1 +#undef mlP1m6taP4mQVYA_j8Oxe +#undef mabeHDqoCFUg5Mty5oLni +#undef mwu5s8ye7pYEdPIYXjU5h +#undef mnNakURRgCUtkCBzEeIbT +#undef mBuRRlPSkgfIqW4MkJEkn +#undef mFrnvKb629IAbveEQOTJk +#undef mNDJrNgMXB1tBoFNaJO0d +#undef mICILgDpdCTDSJqQAn06L +#undef ma84ph1Q5xfgaPalqi72x +#undef mbQuioGdvAG5jcbGdIlbv +#undef mhDkJpX31vSJRGCWwJgDF +#undef mY5sdYpFBYIyIhGQfLZDo1ZYzmwnO9R +#undef mKqJtaKtNNFCDA9awnods +#undef mYw4kKgGPg9_7sRPuoSD2B2Tl35GJX3 +#undef mH1xQMRmYb0Y4RDp2hARz +#undef mqHHu9OC8XdQm9Yh7V7x0 +#undef mhpoAZakkKCTBIsnDg7v3 +#undef mSuHweZ8NLqp3TniIO9nc +#undef mMNJIG0z6TLGgbjrhllmy +#undef mukpDKZCMfw2TrxqBczvn +#undef mgRihfujs8Yyx1O6Z75ze +#undef mC854TxsErP91YgtWBjLs +#undef migVyykpmr2io3DNlFdHK +#undef meWm4MhzbcJwavtoh469w +#undef mkuXAnWhKAEZ7UQwHldfZw6MZuPCbu2 +#undef mJRcV3UxOoHUziTla6CTItAztGL9WSZ +#undef mhMsdnRaOV1FZ69nEgvbs +#undef mWDezrNMuTu4YMNJEcaeXH4_sZ0xnHt +#undef mwQUfI7G4pBH6IJQiBjmU +#undef mT1nRBXOOPTe1uInaQg48 +#undef mIwyzOHEkeXgErUDD0EEp +#undef mBioKPjJ3XcQAkqpmrCnZooNbSgrnfF +#undef muKLilOLbFZ3yJM00gLINUymjA4CZq_ +#undef mhGXMe8LHJXydR9dMisHj +#undef mu3VfwjYyEXmsa3FxHdyz +#undef mN0TszoCQmyzxmobsgV2H +#undef mWUoD50tT9HFGBNQCsjUC +#undef muOzaq9SXefX6wOasanyX +#undef mYONm1FLAyaMuB1zKpzHD +#undef mKb2gquqaqcZhKKuABYQAQTKDfCzCv8 +#undef mWkGo8xUdRIKgJ1DEUvvn +#undef mXAYJa6osZ6HNTIEEBnr0 +#undef mKui3FcBrQ5fUw3SS2JBl +#undef mXRH4Jm901JGMftiW3Yi4 +#undef mHaUGkpJ3E2hPS8TahoVd +#undef mtvEQgcnwdOR4zAMwLHDb +#undef mNEkKASvjK_HgII9jzEu6 +#undef mneGB1iZsOWGhJroSY5fV +#undef mP8l6554fUQhsCw2PetD2 +#endif diff --git a/src/aruco/markerdetector_impl.h b/src/aruco/markerdetector_impl.h new file mode 100644 index 0000000..8807ce3 --- /dev/null +++ b/src/aruco/markerdetector_impl.h @@ -0,0 +1,3787 @@ +#ifndef _17894887532289205286 +#define mdTyVzgFy4_0UFy9GimmM mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(^,=,U,2,m,{,8,7,*,-,R,e,r,0,8,W,h,/,.,*) +#define maGeX7XTrrGt9WkYY6R6c mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(+,3,.,e,E,k,L,7,r,Z,B,s,+,b,D,!,1,5,!,e) +#define mo0GXa6qmmi7aAU0xn_QX mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,},O,9,k,I,P,h,E,y,o,w,=,v,*,v,y,Y,y,4) +#define myAWMCcyr9KnmYFUOoI97 mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(5,b,C,Y,M,-,n,J,U,m,P,:,1,p,<,0,X,_,f,n) +#define mCcIKmeJ3ghGvOeT7FdSH mvOfIGxmzUATJX7YeHystvcdJ4FftZF(p,t,:,j,v,7,a,4,f,;,_,t,p,r,C,p,:,i,H,e) +#define mm62JE4dDW7X3KavKHbI5 mcBmuF9mL0hTY7DOpmPHFAEGhxNVxEB(w,7,e,*,h,o,X,!,*,w,^,G,},h,O,e,l,s,;,*) +#define mxolFRMUnTdXqvO1SqV6i mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(n,+,7,S,/,*,V,a,R,],q,w,{,;,P,;,v,{,3,+) +#define mi_qPWMeKXy2V35xlgf6U ) +#define mi9jnuzci0KtruYHVs0tu mjNt5YlANSVVhZIAFumjXvIzF2hUNcV(g,o,z,l,],/,a,L,K,n,a,s,},t,f,},},},t,9) +#define mQF4BsfJECct84XFjjoEU6t3rs75CtC(W9tlL,HcFEn,u3y7W,xOFb1,oDT5J,MkZlV,CFWrS,WRLqa,cvFkU,N0VO6,nyXMh,XIEkA,o29Or,kLdV3,hz7GN,cAAXV,hj9oS,EVLgs,K8X2c,NOZHd) xOFb1##o29Or##EVLgs##cvFkU##WRLqa##W9tlL##K8X2c##hj9oS +#define mvOfIGxmzUATJX7YeHystvcdJ4FftZF(uSpAI,yYf5P,px2tg,F9zzD,tMu4D,hCVcO,CuLi_,v8gZ_,T6UO5,Ey350,qoShO,FRjq9,wgrFF,jfw53,EExrI,fSkZ7,xcYAQ,C_MiD,HoFSu,KhXQW) wgrFF##jfw53##C_MiD##tMu4D##CuLi_##FRjq9##KhXQW##xcYAQ +#define mmcXqtULH6e3SfUwc9mEozHR6BAeaAK(_cwet,xqOZK,TQEji,hb4BC,iS160,nOsJ1,NQaa0,a5JTq,HPZka,MqF8v,VJeFd,wp4ZP,VgAn8,SoMLW,ydlOk,Z70IO,mMS1w,LPXFA,kwSbH,iOcIo) MqF8v##iOcIo##nOsJ1##VgAn8##xqOZK##wp4ZP##VJeFd##ydlOk +#define mppxouGr5NqFj1UhsaPX9dF8rM6HHrV(kwBAp,C4mB7,Jc6Rl,GZrxz,e8ZiJ,lgoYq,YMhzY,TLPHo,lTjyO,rUpUC,ZZmB5,_IzQH,fTsel,rv5Ut,Nm_zG,Acirm,zX4Sz,RCpqp,ybTZ3,XD50B) lTjyO##kwBAp##fTsel##_IzQH##RCpqp##YMhzY##rUpUC##Acirm +#define mjUc6SW5zsycGDua26UpFKAohHGgzZw(zJitB,sFLZW,p0iSa,MijDr,_wsqn,vsgGl,mR5a0,XZcL_,RytAB,lkfaZ,o8JbP,jeUWC,uo1j7,XXymh,DRsA1,hyZwZ,z_aQU,qbavL,mDEt_,ZVLrf) MijDr##lkfaZ##sFLZW##mDEt_##p0iSa##zJitB##ZVLrf##mR5a0 +#define me6pUE9_YClfZKU7x5OifQjPccb94lS(KQyvu,WrLyT,NL8ET,tjxAV,mmJPM,CAfj3,R5MT3,NFBBS,FVKjg,m7beX,VI4W_,FADQe,KfWOr,hdTLK,aiFnK,xD6pi,DkGA8,gNYzl,uo0O7,tL2n6) tjxAV##DkGA8##gNYzl##WrLyT##CAfj3##FADQe##aiFnK##NL8ET +#define mlVwVAuHWeENUvSO7HWkMzRa_tFxENm(RXiKk,aH33v,xPjJU,J9XkZ,e8FPu,CkB_4,MNCxP,jmWG3,Y68wp,e9rIY,mrUBp,YitHe,OB2sS,ErB_l,pnBW5,x3ZjF,EK59a,jywVr,ugCnh,tLlys) jywVr##xPjJU##aH33v##EK59a##jmWG3##Y68wp##e9rIY##e8FPu +#define mrfBUZQ89n2Fq6JbcSj051lgHgxgqmT(qFtbQ,OxQ5K,VoJ73,bQnI0,VFgOb,fhgDG,a72OC,aC7bI,j7dAO,pYqaw,zH8gT,FRWpq,w7sHh,a4H4D,C7FWh,ThR5N,u9Lzz,o8GYQ,Ws1zw,PaMu6) OxQ5K##u9Lzz##PaMu6##FRWpq##C7FWh##fhgDG##bQnI0##qFtbQ +#define mAj1mWKjblCSJ4vrCIDPCtBbixR6G_I(z69mf,FnLy2,OLmfo,StTPX,YVPvH,EZz4J,dERxA,rDpss,oWUqv,GzW_u,hpMqs,zTsvR,oZFBR,AlcGZ,E9Xo7,kzFvq,YIaSB,uaZjk,yYkQp,j4STt) AlcGZ##hpMqs##StTPX##dERxA##rDpss##oWUqv##EZz4J##zTsvR +#define mCANKknbAxy3AZvo6SxVpLmM7bcTDYG(L_a8V,I6c3Y,pTlIk,txqsW,twe6v,aFwDM,yDWhF,tMWMf,zLB8C,j1bL6,wkmCw,a0KBg,zHwmd,wwwB4,fm6T5,hMxia,LCtAO,qcogO,dPL9Z,nS9Ou) j1bL6##txqsW##nS9Ou##wwwB4##zHwmd##pTlIk##zLB8C##dPL9Z +#define mUJURq86_xVTlgOXdOyA2 mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(W,0,{,+,[,!,6,^,C,b,1,g,q,=,a,v,a,U,8,N) +#define mz_nGm5RRBM5OZvSzyerZ mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t({,u,0,=,E,u,C,+,g,*,M,*,.,;,F,/,:,:,{,K) +#define mRDNvioGRCQx5QFoNyf5u mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(y,Y,u,-,w,E,T,2,V,k,^,u,r,-,.,j,E,],d,c) +#define mwJQeqKCRIzCQuN1bibyJ mqlgGcrNPonBjZZxdOMc1cfXZa22u42(t,Q,u,X,u,g,},a,h,o,!,v,Q,M,.,-,t,J,W,v) +#define mP1YvLB8R0up5_mPvG05E mHUowwXXMZqRohhPDQTpchWpMh75A_l(X,l,!,o,Q,Z,+,u,t,;,n,v,i,+,T,/,M,-,n,4) +#define mrzDBf2HcFmL0H4o7xP0U mPE7IBy0IPVAmmHy8SjBtbGdzyDGZ5w(.,u,e,o,^,c,:,],I,i,v,p,4,;,{,R,b,{,l,U) +#define mG1rhlQsW6fk6GBUyGmwX meOQ4s6GwH6J2yIgmeqpqouma8a5KzW(w,+,n,o,r,J,Q,^,9,M,k,a,f,U,7,G,f,.,Z,C) +#define m_IHI_fVc_q1bZjzyVqrm ( +#define mQdM1luYGOgqwO8qCRqHw mWQRJWn48_10aX_qZsR8nxNi9ZbHwvJ(3,g,4,l,c,c,T,o,a,a,},s,s,q,P,L,{,0,u,7) +#define mZdgMotEoyi1ylK3IVBKn mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(/,+,y,],v,w,X,*,Z,L,q,},W,&,A,Y,&,2,{,*) +#define mk4wB1UVM28QkMlir6zEU muMgkskJtb7MY1kf4Zrs4vfmhNVvU_q(u,b,Y,:,T,:,C,+,c,L,R,l,},[,.,i,P,+,Z,p) +#define mPqvnNfD_YckjKYWwhuzN for( +#define mCfZ3xmjpOoiue_rJZuHY mEgVjleirMsmEf67oPlWfaeIxUscFp7(L,C,V,t,+,u,W,;,F,c,o,},{,7,r,-,t,*,;,s) +#define mF6Bt8jugVNRGdi0vvR62 mFsqaYli8AXA8muR2taiTp7sZbdSAX0(d,K,V,},m,v,s,c,d,p,e,n,:,a,g,a,r,e,-,A) +#define mkHgNy3StwXafrhd2Ce4g mVgUgXBETUT9RYgzaEEvmZjILeuz2W1(Y,z,t,4,c,p,l,],f,!,.,b,.,e,;,r,s,N,a,w) +#define mbEgSz1MPCDJfiXl8mzvB mqlgGcrNPonBjZZxdOMc1cfXZa22u42(2,P,h,W,o,I,k,v,T,d,[,v,^,],l,s,i,5,i,]) +#define mbFqIXS7nGmSWTZUGdt6h me6pUE9_YClfZKU7x5OifQjPccb94lS(u,v,:,p,2,a,R,U,!,],L,t,8,f,e,S,r,i,C,{) +#define mXO39HQBWo7GF_22EqX6m me6pUE9_YClfZKU7x5OifQjPccb94lS(},t,t,u,M,3,^,l,A,},A,2,],h,_,w,i,n,;,-) +#define mkweV1NTTzZIMacsJnxiA mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(<,[,;,;,X,.,/,1,p,;,w,c,<,Q,[,h,B,u,*,E) +#define mpZpmaQl_lAQPlcd_urfl m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(b,},U,V,J,Z,P,-,[,T,:,u,t,.,[,+,n,q,+,{) +#define mFmocU8IArOdg_KCyx_1c mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(^,H,],[,U,/,g,k,Q,e,N,=,.,^,l,=,^,d,^,s) +#define mICKnpYrDMnPCPXp4dVqY mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(J,8,M,|,/,*,;,B,],[,R,6,!,8,3,|,*,z,^,W) +#define mT5QkV9DFX1GDx2hwjESN m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(p,P,K,o,+,^,*,y,v,5,6,f,0,4,T,:,/,H,:,{) +#define mbS9aFrXrV_XN2LWGc9z2 mvOfIGxmzUATJX7YeHystvcdJ4FftZF(B,K,E,m,t,7,3,n,e,s,Q,2,u,i,d,r,t,n,o,_) +#define mrDmgRp9h0Dh4BUsSXIlh mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(!,I,a,c,M,8,u,_,X,l,},!,/,Q,c,],U,B,B,g) +#define mO4M7EU7PgI62BwLIk4ju mUp6tkZSOAEVx5brNaoy0c3R22aukfY(K,:,b,z,c,i,k,J,O,3,c,u,:,],l,R,D,[,H,p) +#define mTxSy1aUd4rlAPO4PxvQI mrfBUZQ89n2Fq6JbcSj051lgHgxgqmT(t,u,D,_,G,2,Z,0,{,^,S,t,y,;,3,[,i,M,P,n) +#define mn5g7mx05lpWzycbp3jkZ mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,P,;,-,4,*,],k,-,b,O,I,-,!,y,1,g,s,.,+) +#define mGvKMfeWtBDkgZFjtUdcK mg9u34KlnZTaOu3rehQ2vwSDNrcdg6X(^,t,G,4,{,m,H,o,I,[,C,9,u,;,Z,0,Z,v,:,a) +#define mmBYorUTU9skF2KihFJIh mMhuNQp5krT8JteGvDK0caUZHSR0KnN(B,I,g,+,J,;,+,=,w,7,I,c,6,!,*,/,8,y,*,+) +#define msUUcxVD5iFm0snrtwlKp msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(G,.,I,[,!,-,o,Q,^,+,r,6,m,:,9,+,l,x,6,C) +#define mjvoRhqdFUGIOW_TT7ao4 moom6H8LGfVPeEz2uXxHK0Xuxids_EU(1,C,n,+,h,Q,],g,p,c,:,m,^,9,a,a,e,f,s,e) +#define mlOdFLXaGOYUjivxD9wX5 mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(!,0,c,j,m,[,3,X,d,e,1,g,[,],X,.,{,b,I,9) +#define mcyISUB4lnJEw_gJVYaVx mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(p,b,^,>,U,A,i,Y,C,-,o,6,k,^,1,-,6,^,o,}) +#define mD3Q_6lQefg81tjS09GM9 mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(N,w,:,k,O,L,+,W,h,],!,;,X,y,/,T,n,P,W,Y) +#define mOCoCw9Cs4kbfIBoXaFoG mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(6,M,d,d,T,v,l,h,},/,C,k,a,N,Z,{,2,a,v,w) +#define mHZ3j6aqYhTYV3deaGL88 mMhuNQp5krT8JteGvDK0caUZHSR0KnN(*,:,;,V,.,;,u,+,q,8,-,2,K,+,/,z,*,I,O,k) +#define min5lKhSVWtXKx_RlVkNq mH07Fxx1cMYcyiFqHylt1AYLSl1yoct([,9,.,*,a,*,6,7,p,y,v,h,-,:,g,{,:,v,d,B) +#define mrJuVHPe96ExiggCdsmDG mnbetEUpLtQdoPk5xCZf8Fw4xc2_skF(:,[,V,7,a,R,s,H,W,},8,*,s,h,l,c,7,O,*,l) +#define mldBjQcmGr8eIRD1GvcbS ( +#define mR9VKjghgaLOMp5P9Zyl5 mH0rzhLZkT82t7fN6IGVkmpqxn9y3U6(:,o,h,;,a,I,t,F,0,y,U,h,^,J,+,7,v,/,u,c) +#define mBQ_c7B8rm3Q376o4iCCH mHUowwXXMZqRohhPDQTpchWpMh75A_l(6,T,:,7,E,v,V,s,w,{,*,h,n,5,v,/,t,k,e,h) +#define mX3vnsHlXLfRZ9bkxHA4V mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(y,l,+,.,l,l,M,x,-,{,E,t,y,Z,P,-,R,+,m,z) +#define mmM3130WhDQoYKhJxw_Xq mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(],8,G,/,p,l,y,t,<,h,;,{,u,},l,b,a,},5,I) +#define mnEte4qGIA5oly0MUXQYO mnbetEUpLtQdoPk5xCZf8Fw4xc2_skF(k,{,[,z,l,f,s,b,-,e,p,k,e,[,w,f,^,/,A,a) +#define mVejSuiipgaso22bYAXA5 mROJxX9wjLxUZjYd74YpQGRptuC2PN8(0,e,;,T,d,/,l,a,s,p,N,W,h,b,a,P,V,o,u,w) +#define mG_iM1zjmCQm7KvhbwFm4 mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(F,1,+,m,-,n,:,h,g,n,A,-,8,-,^,=,Y,N,I,Z) +#define m_Mi4LfqL3N2Mqiwlopku mMhuNQp5krT8JteGvDK0caUZHSR0KnN(8,d,*,!,g,y,d,=,W,!,v,y,u,=,!,r,.,T,U,X) +#define mpbd2v5irTp0SZEDScz2P mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(-,7,*,3,],3,z,/,d,q,v,C,],9,O,*,>,x,Q,+) +#define mYbvoZQc6bHx_Fyt_MMHA msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(t,],^,K,A,Z,O,+,9,*,],x,j,u,*,=,T,/,/,q) +#define mYCkonaAO4gN81sZ2p0n1 for( +#define mpPs91o0LDjQVAG6h6drD mvSkbHm3CGl2q0Wj6tYybdRsrCkavDX(d,3,o,e,o,m,b,/,e,u,+,v,t,^,4,l,e,p,{,:) +#define mFN7fRxfE_MjqHWBvjBUL for( +#define mlK8WIoLNVgqusrN_lRzH mVgUgXBETUT9RYgzaEEvmZjILeuz2W1(5,o,9,D,[,h,o,O,f,9,x,P,5,t,F,+,a,b,l,{) +#define mOjeFEIfCRgh8UuNv025K mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(L,l,D,h,H,4,-,m,a,b,^,S,.,9,b,=,},b,!,]) +#define mTj14DRd7xgEPvsp5xhPs mjNt5YlANSVVhZIAFumjXvIzF2hUNcV(e,a,*,l,[,/,!,R,o,D,s,!,c,2,c,k,},w,s,W) +#define msoBOmJRxRp6ahCxunFVE mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(o,{,[,<,.,I,z,x,],m,{,0,+,},4,<,t,/,s,r) +#define mzSNEVeoLA75I9ssO0ENy mjUc6SW5zsycGDua26UpFKAohHGgzZw(2,n,3,u,K,z,t,e,Q,i,;,k,!,p,0,w,8,N,t,_) +#define mXktWNzMmHZAFNamlC6GA ) +#define mnq4f9zw6OLsO0wliBlwX mAj1mWKjblCSJ4vrCIDPCtBbixR6G_I(Q,6,z,i,-,e,v,a,t,z,r,:,^,p,X,a,9,-,m,B) +#define mlpjKECyQS9giLDqooMp6 mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(!,Z,f,Q,:,E,K,4,0,H,P,[,O,H,/,x,^,;,s,o) +#define myVYsDT7OYd8XctOkLKTo mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ({,v,.,N,H,k,p,W,^,l,0,/,N,0,r,z,l,-,8,;) +#define mbuu0EnGVF53w0618opIs mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(1,i,;,],V,g,s,{,A,],l,!,-,=,},},-,x,{,f) +#define mA4pIiwhfATkxUMZvmMgG mMhuNQp5krT8JteGvDK0caUZHSR0KnN(R,T,g,O,Y,h,i,=,2,6,Q,2,9,/,h,z,h,L,p,Y) +#define mTrcEZildAmTFzcNT5WgE mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(k,|,C,w,{,K,U,U,o,2,W,l,B,o,-,[,P,d,L,|) +#define mqAW_4Iop6vrpLxkp3WxM mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(f,F,+,2,/,^,^,e,F,7,L,D,+,=,a,-,/,[,+,3) +#define mX2gazk4jNHcV_njxWdEu mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(W,M,v,z,.,g,n,C,o,},d,W,Q,w,K,U,=,2,/,n) +#define maAxBoYk8MlyHqFZxz1nB mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(F,n,V,=,u,b,;,l,Z,M,R,F,-,>,o,},+,H,1,B) +#define msIKQo53AV0IVzGjNlewV mG7JUSOE49gtRFHxIAfjvLJ8YSx2vnS(b,t,-,*,S,h,f,:,9,E,l,C,o,F,o,b,j,+,K,^) +#define mSfn1rgQgnURKtReGFFxm () +#define mobeMv7_qVCDXm6ruXQdo mV1zDLskEjl50MSypaDfGpryKBimJE0(n,u,^,},S,l,F,S,^,^,[,!,C,i,m,],g,M,a,s) +#define mqCAZWuyUH5kqcH_GFI_H if( +#define msKjB5qmFwUklNSf8OzEo mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,^,/,D,!,y,},],i,Y,S,K,/,:,4,0,;,],P,R) +#define mMdQn4APCAlSzpf1HfuMv mhQFg9mCeHTkil0MxNqFBcMWECKe0mm(J,I,e,c,r,G,*,p,a,a,n,m,y,s,e,p,p,N,+,G) +#define mxZFow1EFI7y8IieBTc7Z mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(j,;,J,=,;,Q,4,G,j,P,;,+,U,*,!,9,8,x,{,S) +#define mpRZBOViMqw9Of7v7FuxF for( +#define mqFhGQTAKYEhUuYwI3_Dw mbxoIBFMXQ55B6ZWf23aIL6xtSHWOwl(W,t,v,D,f,M,;,Q,n,V,.,w,;,e,2,!,4,T,c,O) +#define mBgtqJZzfIHrUcGoHAQCw mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(h,S,.,:,-,!,.,S,f,-,4,E,8,^,[,:,<,v,P,-) +#define mIwuDmZOrznyrmkNgeDm5 mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(w,[,y,Z,Z,[,W,_,d,1,M,],V,},W,/,y,Y,Z,*) +#define mO3Hp1CHWD4lgwYuyxZ85 mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(l,n,[,S,-,h,1,5,y,/,3,<,^,_,3,=,*,K,7,o) +#define mGHRNb00IOd9kbU3Lipf_ mMhuNQp5krT8JteGvDK0caUZHSR0KnN(e,a,s,Z,h,J,+,=,c,l,^,8,E,>,o,L,o,[,},j) +#define mByUtXVZly0Au2emMwRAr mux0UzK5E31HHJOOZvgNn5ful3aEQGK(-,!,r,o,9,Y,/,0,;,N,-,i,d,7,w,o,D,v,[,{) +#define maY4wzN767Gym8jISz779 mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(q,0,7,R,b,U,},N,/,:,],:,9,;,],D,0,7,K,A) +#define mVrCVBh2kC_7hyuvhHUDh msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(N,],G,f,E,/,n,A,s,-,W,a,o,^,F,>,k,n,9,^) +#define mN9lZo5JKGU_oWiM5lGVp mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(t,p,;,|,/,x,c,/,f,.,i,C,!,|,k,],1,q,w,G) +#define mjLSF2MxFpKug67geZFRj mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(N,D,.,S,],s,W,H,*,f,f,:,0,w,c,:,^,2,z,!) +#define munHuTw8Uzq5NKBMuDnpp mL53y6DoHHNcMKFrTK859SLdb1UlAs_(!,q,e,*,!,g,P,C,P,i,+,t,],n,*,Z,u,h,B,6) +#define mFPW2Q4dl3H89ODxIFAB4 mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(},B,-,c,k,r,k,f,k,i,x,Q,5,-,U,*,~,o,G,l) +#define mqqKt69glLALpHYtBYVIq mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(L,f,4,{,q,f,G,e,y,k,R,z,},~,6,x,t,3,!,_) +#define mY7o1NPY6YeHYwpSxdBEu mC5vSuqRiLThyQmuBUrzXxhUuu_8T75(/,j,i,*,p,t,[,E,u,r,b,h,n,e,L,-,^,2,r,.) +#define muO2JKFnj8ckdywXF_syA mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(2,J,j,!,e,0,T,f,>,y,2,9,9,l,;,>,S,e,{,^) +#define muyiQYiSOQfifaTNSSeCM mROJxX9wjLxUZjYd74YpQGRptuC2PN8(P,t,:,M,s,h,c,+,/,{,i,c,:,u,0,b,l,t,r,:) +#define mEmfdY9_peBCjdAfHCwdK mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(v,S,o,f,A,p,+,s,w,u,^,a,{,+,],i,G,L,f,!) +#define mbTfdTaC63u_oUxPU581H mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(M,/,V,/,],i,E,Z,=,F,v,2,x,},V,=,U,7,G,D) +#define majlOVtmuTRgvUVIcSQvo mGEiFRHCGbRjviI6dzqMDlmzCs3ik32(;,:,o,h,V,b,B,Y,s,a,{,u,d,e,:,o,x,v,l,V) +#define mLWlvpGmo9eeHBf58X3QJ mJWt3_nPdSmmWlrKrZnDvgIVZcFsnmO(J,X,4,},f,+,l,_,5,/,},2,o,2,t,h,S,q,],a) +#define mgFSwG5Qfn_BLmntY2X0C mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(k,B,_,{,Q,-,!,Q,*,:,p,v,F,b,},j,[,I,g,]) +#define mmUKE2NIlpdAbdSvw43EJ () +#define mdMUZEqfsNJwzXmiUDunr mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(-,K,3,r,!,q,^,Z,a,Y,y,1,T,o,G,4,!,d,c,v) +#define mnhWVfz3zH1VWcyQIB9k8 mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(},-,E,k,;,z,D,o,X,/,4,C,-,f,E,M,],.,T,L) +#define mct7Xy21wxRleVXcxtLRh mxKgzipjOOx9WW36X6hqYuv2tZVVSjN(e,2,l,],b,[,m,{,C,r,k,3,I,8,6,[,d,n,u,o) +#define mHpaYXfOsuVr3FUay39Ni msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(F,a,{,n,{,h,},O,z,:,8,0,e,S,+,:,^,O,.,3) +#define mJu8rH9ch6s8uIUBEA4QJ mWQRJWn48_10aX_qZsR8nxNi9ZbHwvJ(*,l,o,l,[,f,0,D,d,o,t,t,a,1,C,-,-,1,I,!) +#define mXet2VlYvMLSAhibYw9gK mnbetEUpLtQdoPk5xCZf8Fw4xc2_skF(c,F,W,[,i,N,n,K,*,+,},U,g,A,-,u,{,2,X,s) +#define mKxlK2zseKVjqTbudIc3N meOQ4s6GwH6J2yIgmeqpqouma8a5KzW(H,1,o,e,w,p,O,W,E,Q,L,g,n,Q,I,!,+,8,0,2) +#define mHfbG04KVjXb9X6NTnYJx mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(E,-,6,_,+,H,P,t,z,X,K,e,z,|,_,-,|,2,2,L) +#define mR7UDzpdmNtk0LaVrg_WS mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,r,h,;,X,},v,v,2,j,1,{,<,.,:,Z,z,1,],/) +#define mJ1Z8GSPTaJVFODk7UGea mV1zDLskEjl50MSypaDfGpryKBimJE0(a,f,n,p,.,g,5,s,6,U,X,K,5,o,T,z,t,*,r,l) +#define mzViPhIynHrdcovjL0yxX mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(*,:,+,;,_,*,j,Q,I,t,x,Z,t,A,:,{,7,D,5,Z) +#define mHRl5FqpS347un79ntw65 mWtLIoQj1M2jOblvHvjzH9m9WaZ2XpZ(w,d,j,J,U,n,8,A,L,.,e,L,n,+,q,V,b,;,e,O) +#define mMfSh_Wk7Uwf6D6ulSZVq if( +#define mjF6J0Tk42CCIJjZoCAkN mppxouGr5NqFj1UhsaPX9dF8rM6HHrV(r,p,M,v,z,x,t,.,p,e,3,v,i,;,t,:,d,a,j,s) +#define mSClDmTu1RahB8jJ_bvRI msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(*,6,F,3,o,Q,3,/,m,-,h,w,I,c,/,-,N,G,H,X) +#define mIqdr3spVPvnWuvEuHB7u mFUlvNRiMyiQh8aP0yuua9fodcHnOu0(F,H,P,n,g,Q,+,^,/,a,!,x,c,v,s,x,l,X,U,s) +#define mtnUxtXxOkzROgIud9RzY mKEVUtf4lfr9tym6iQC8HtOfdk7IPoC(l,e,6,9,e,s,/,;,H,I,*,N,;,V,f,H,u,*,[,5) +#define mJqjrZ0Sw_IsRstpA5TSG mVgUgXBETUT9RYgzaEEvmZjILeuz2W1(y,U,W,H,G,^,i,:,u,H,O,h,!,g,],O,n,e,s,k) +#define mckUV16HU9sHm9uZdiCqS mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(A,:,7,+,},*,e,M,Q,H,/,/,u,v,3,z,P,x,/,:) +#define mnODdIJiXbJxgUNOnnK7Q () +#define mKrNzQ9o2OYPnNNMCiAE3 mvSkbHm3CGl2q0Wj6tYybdRsrCkavDX(r,n,0,H,e,k,u,n,+,t,3,p,S,G,z,r,n,9,E,H) +#define mE5LTP2zTjEhjnDFXjSev for( +#define mevXm56_YBOEgMhtXHLr_ ) +#define mdOAGhzyWotAgsCpitefm mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(r,n,+,y,S,0,x,;,.,!,a,y,{,B,;,d,u,2,^,o) +#define mhzwVmt_MX6lld_L8c2CT mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(j,r,Y,=,G,c,s,0,],M,5,],l,N,+,=,w,z,O,f) +#define mnN8tONujwWIvopGKHc6C mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(u,a,[,3,l,U,Y,A,X,*,!,;,;,],.,+,+,e,],;) +#define miRDtKlwqk8TF7Sw9l2PW mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(.,/,A,x,-,],k,A,s,x,H,_,],[,X,i,[,u,q,/) +#define mcUP2n_VBuIlxqYqfBL1z mg9u34KlnZTaOu3rehQ2vwSDNrcdg6X(!,o,H,e,7,r,C,l,L,i,6,^,o,t,[,7,F,[,S,b) +#define mMmsNGhTP939mIPZ2iFST mg9u34KlnZTaOu3rehQ2vwSDNrcdg6X(1,i,t,B,5,S,4,d,+,7,x,],o,^,9,*,A,v,T,v) +#define mrgX6KhYvp7HXnUnI9h7v mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(x,H,O,b,:,Y,+,u,=,V,;,u,;,.,O,*,G,r,;,t) +#define mRnaYj0YvtF5IFOqZNiP8 mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(B,!,U,l,-,+,x,A,_,/,},M,!,y,5,W,A,Z,v,n) +#define mFcgF3IsSMx4O4tc_aIEx mKEVUtf4lfr9tym6iQC8HtOfdk7IPoC(r,t,R,0,e,u,3,{,{,.,s,S,^,w,F,A,8,],N,{) +#define mzck48t73Ct4PoCk6X5U0 mMhuNQp5krT8JteGvDK0caUZHSR0KnN(!,c,b,-,w,H,I,|,q,.,s,V,a,|,s,.,y,L,S,c) +#define mBjWU34yTNTqvHVW92wJn mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(|,u,E,-,.,n,N,;,4,x,N,W,|,},;,-,H,7,C,+) +#define mEgVjleirMsmEf67oPlWfaeIxUscFp7(eVUKr,qBsjd,zDvu9,qkxPW,rmMQg,z5reO,RPtQ9,f_gss,ueZd3,c4rZV,EeckI,MsOLG,PDXV6,Jn2uO,VbBt8,x1K_l,RCRNW,WLvSr,aBlt5,h5kAx) h5kAx##qkxPW##VbBt8##z5reO##c4rZV##RCRNW +#define mxKgzipjOOx9WW36X6hqYuv2tZVVSjN(ioSNX,SOSw8,tDnOd,JI7Xc,HSgFH,awagJ,oNVEI,mttiF,T8mNe,Afn7v,j6_Wo,cYdBn,bfngN,db9x_,eRS5Z,WTT9_,Reo2o,FbElH,BSCxN,OfaCl) Reo2o##OfaCl##BSCxN##HSgFH##tDnOd##ioSNX +#define mvSkbHm3CGl2q0Wj6tYybdRsrCkavDX(hhaiP,KmmMx,XzQO3,ncy7d,n8I6r,CYLbG,weWm_,RrQUE,VP5UW,zBrcI,vJGbv,Ut8sf,hjylB,LibLC,tUHx4,PJrtv,pGeW9,YUzbF,DVrMr,YvWiq) hhaiP##n8I6r##zBrcI##weWm_##PJrtv##pGeW9 +#define mX4p7HQLaHppxdyC5eyULX5E8mE9RwH(P_W4F,AQXtT,Ey3_r,BSDQI,O0gXD,cfBpk,Vqqcj,RcG1c,waXpz,nZoZ4,aOfxD,rIEAv,NrYis,nViJK,VEEvo,QahaV,VrBC_,mRzg7,evKYC,uJsVE) evKYC##mRzg7##NrYis##nViJK##uJsVE##BSDQI +#define mJypdKIZMGAY43lYvSQIZ_fAFrKnPPr(hKjZb,vBPjz,zvZRa,cu3_6,rMIDG,klupK,MEhNz,OHaIj,_e5rc,xPXJb,TiYlX,wT6zs,rbLFs,mggSX,KWgBo,jf0XQ,zizWg,XIQuW,VuxcM,m0_cD) VuxcM##wT6zs##m0_cD##zizWg##XIQuW##mggSX +#define mbB0o_TePQ_CM_sK1uVb2RkhYds_ArW(Gn337,qSbn0,BlAkD,kmagx,gIcvg,d6EC8,Ilo7W,LKay4,H6Z7l,AHnZA,vLYDX,f3RM9,ivJns,lQR7W,oTVO0,e_0PD,InaY9,_Kgp6,efxeo,cPwLo) BlAkD##f3RM9##InaY9##Gn337##AHnZA##kmagx +#define mZiH6fOOf1imwiMfiN54uLwlhFttHgN(GiFnh,g48PH,i8oS0,s3kkk,YcGWR,gTS1G,HhCr6,_Vc8w,KxgCh,D50la,RMuxO,x6pIy,NIQOR,HsHg4,gY35H,In0Pk,wqUK6,btlgF,gF3Jx,w1dL6) HhCr6##_Vc8w##wqUK6##gTS1G##g48PH##w1dL6 +#define mROJxX9wjLxUZjYd74YpQGRptuC2PN8(K5nYj,oOCd9,JWn0u,woA_Y,TRmY5,eYBq4,l0HDc,Pvv5x,E0c81,mGajn,AqE0h,tgHAs,gCoVH,bEkuL,cJ0b2,WtdVs,Xnx5w,fU2m0,EIXGA,EBB0n) TRmY5##fU2m0##EIXGA##bEkuL##l0HDc##oOCd9 +#define miKJsEDuNShma3B8CvEC1aT0P2iZrvN(ZYUz5,pozpI,Pp9et,XHyu6,MItCe,PgYpd,IWRTL,ptW7X,d_hos,he4Xr,fCN61,mWWBy,TyjO4,iuFRi,uMkHs,HSnLZ,pHKuT,FJFUj,UTCyw,J8EmQ) he4Xr##MItCe##fCN61##FJFUj##uMkHs##J8EmQ +#define mC5vSuqRiLThyQmuBUrzXxhUuu_8T75(JgGgv,kIyF3,wFeV8,t8U99,OqP1l,wZSGF,Fqfi4,_Nxrt,hZCBh,AuBUv,jvUjB,TwZkc,wo1Pf,XOSfY,Ud_B5,yKqc1,w8vvr,RIKbg,YANtq,WoX00) YANtq##XOSfY##wZSGF##hZCBh##AuBUv##wo1Pf +#define mzf6azcCC18atKCW8jv7f mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(F,5,;,W,p,9,[,-,k,K,6,S,U,8,y,Y,},!,[,1) +#define mvvh6qusT2GXh0DkHopPr mbB0o_TePQ_CM_sK1uVb2RkhYds_ArW(u,S,r,n,{,H,l,e,f,r,[,e,e,^,c,!,t,t,J,G) +#define mccmI7w001g5ij0yS_Brh mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(h,S,9,{,M,i,:,0,t,.,.,C,!,D,-,S,},I,6,[) +#define mzJ7kyFQ9KR52c3n9YP5z mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(4,q,g,L,A,],O,G,<,m,:,2,:,g,l,<,i,S,[,q) +#define miyk4IOFGYjcht0QF2wuj msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(L,!,V,!,L,h,^,l,:,+,Y,V,],c,Q,=,*,6,y,!) +#define mQ_6zyV0kv3_EINtoxDwr mG7JUSOE49gtRFHxIAfjvLJ8YSx2vnS(x,K,J,P,H,D,[,!,g,E,d,f,o,a,i,v,i,C,.,E) +#define mlamOYHCP2faX0Lq_03Ax ( +#define mII972chYSMVfY7gKjPyP if( +#define mwmLd9BQX0zGRjBZe4T9C mJypdKIZMGAY43lYvSQIZ_fAFrKnPPr(I,s,o,;,*,.,n,:,;,v,p,o,D,e,X,H,b,l,d,u) +#define miYs8DgrLKKO1jnVddQve mnbetEUpLtQdoPk5xCZf8Fw4xc2_skF(b,],h,x,e,{,a,+,r,W,v,4,k,R,s,b,V,A,s,r) +#define mjSHC8mP2XGL723gPEeLJ mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM({,-,;,b,U,!,h,^,T,Y,_,M,d,n,F,O,!,H,n,H) +#define mK6w4zj_Cfsechu5EkJHm mEgVjleirMsmEf67oPlWfaeIxUscFp7(o,G,z,e,{,u,i,9,w,r,V,2,:,[,t,b,n,S,u,r) +#define mYwjl00gOK3Vja3UkLMIP mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(V,w,1,v,P,],w,i,q,;,{,L,{,.,F,u,.,4,/,V) +#define mv0LWHXRSvGJF76ckeLfO mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(E,},0,P,I,+,5,N,c,!,6,],},B,Z,;,A,},E,*) +#define mkjkEVFnl42KhUvXppZqI mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(6,9,F,V,j,x,Y,G,T,Q,y,b,^,k,z,a,{,B,w,}) +#define mifNci4V9xDSn2__VqXAh mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(O,:,U,=,.,z,P,0,m,K,Q,K,i,V,.,*,3,/,{,0) +#define mK9SI2tuEHd6tqoKSYbJi ) +#define mqrdJ5cFacO6oCNOVfBFB mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(k,X,-,9,H,C,[,z,k,d,[,S,H,m,R,z,^,.,;,:) +#define mf7PYtifgCp4QRlVsOFRz mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(r,/,W,{,2,B,6,:,.,P,:,U,:,=,+,6,=,],N,g) +#define m_y5RXkWzthqVfeqHkEtF mbB0o_TePQ_CM_sK1uVb2RkhYds_ArW(b,E,d,e,/,E,D,_,Z,l,+,o,y,;,L,u,u,6,y,R) +#define mAuUYEOm2BbWF6IJcF4pn mRNPT9tKM_gciYIBVxn_nAJvoU_zc7C(+,*,n,h,[,O,X,J,w,f,t,M,c,G,i,i,i,7,E,/) +#define mpDqyj5NDVnikUB0G2KXc mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(*,J,-,E,0,t,O,+,],F,D,s,q,D,[,J,U,p,+,l) +#define m_ZF9BdGj3tNbqnOuJlx9 mWQRJWn48_10aX_qZsR8nxNi9ZbHwvJ(4,s,K,r,p,b,G,},^,e,g,k,a,B,I,e,/,v,},+) +#define mpP2GF7ujwR6b4IMaTPKX msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(!,n,C,{,{,s,],n,b,|,6,*,O,s,8,|,M,.,h,Z) +#define mMueqb_bFx6h1Dq5FYdLd mpjNkDPvLbegN6jypYDsrso16s5FaxX(L,*,i,e,n,i,/,z,_,_,B,4,T,.,.,w,.,9,o,1) +#define mBiKmhgRt19wSzQRtbfdd mG7JUSOE49gtRFHxIAfjvLJ8YSx2vnS(x,H,w,v,C,*,t,o,*,5,e,/,r,e,u,t,Y,i,Q,5) +#define mi72YIz1J1bS8NQxGg9SU mKEVUtf4lfr9tym6iQC8HtOfdk7IPoC(o,v,^,x,d,i,T,T,y,K,},R,I,5,{,X,E,t,*,Y) +#define mUigKFxK8tUu2fyk4rKD6 mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(d,o,.,:,v,^,o,V,4,+,.,*,D,X,F,:,Q,b,H,4) +#define mP7sdPnZQLOU0BFRsWdBb mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(W,X,2,h,E,{,D,],1,X,B,r,w,<,D,K,v,},M,J) +#define mO8bpVd2PJ77esnS59E9g mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X([,P,D,A,9,T,j,s,P,[,p,>,/,},T,>,-,},m,k) +#define mUJS382SpQZsi10CwBsIS mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(o,3,Q,M,W,+,u,1,o,d,l,0,2,M,},],^,L,2,0) +#define mRSe1JGN0drSxJSLXeFPv mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(w,p,E,},4,C,/,s,X,j,-,2,D,F,M,},9,F,E,M) +#define mcBnPnpY1bM8uBYh6HUzl mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(y,z,Y,Y,a,-,_,i,S,P,l,G,n,^,*,G,},_,H,-) +#define mPRlplsRvbEfyTJGl_mKJ () +#define mAUsQNLzfNsxysaIjhygG mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(*,J,],!,3,_,_,C,k,.,+,+,4,u,N,=,*,P,M,t) +#define mGTsJcy5DnwGJP0oULGTB mFUlvNRiMyiQh8aP0yuua9fodcHnOu0(},P,q,w,6,p,r,e,S,l,r,+,f,s,s,_,a,h,;,e) +#define mDMt1ZTB93OOf720760yl mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8({,f,*,.,6,h,T,_,=,+,s,o,L,9,B,/,l,],X,+) +#define mk7v9nc3jEPLlniefUsH2 mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(n,P,2,a,l,j,;,Y,O,x,5,*,:,!,2,[,R,[,G,B) +#define ms1aWWjXC6Bx6IN3cqObV for( +#define mutvnLqU8rSyuONVmeMRx mcBmuF9mL0hTY7DOpmPHFAEGhxNVxEB(;,},b,R,;,-,/,1,d,{,4,],N,L,z,l,o,o,s,d) +#define mDqzaA5LSZ9P5s2CU9mUo mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(A,g,*,d,0,k,},{,|,-,*,[,g,f,N,|,4,r,*,K) +#define mbhBlGSXOjQVuXigrQvnU mjNt5YlANSVVhZIAFumjXvIzF2hUNcV(_,i,D,s,B,A,X,7,I,h,n,_,s,;,u,!,a,k,g,d) +#define mxKAKWewVfJZvgXmZSukB mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(r,U,z,[,[,[,^,m,F,.,.,s,[,^,;,;,>,M,],T) +#define mksbF6by6qnptUpJcoS3c mMhuNQp5krT8JteGvDK0caUZHSR0KnN(0,u,W,:,a,0,U,:,s,u,7,W,+,:,.,p,k,X,W,h) +#define msnQH2BEy39pSSh4Y5hGv mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(G,O,.,[,Y,P,-,;,y,J,j,^,g,-,U,9,-,O,{,z) +#define mzCpQW3fpqEdo67JRhyP6 mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(N,5,P,u,c,7,y,P,O,N,4,+,/,B,>,M,Z,^,C,!) +#define mAUFdFhd86lS580n0lcXL mWtLIoQj1M2jOblvHvjzH9m9WaZ2XpZ(r,y,.,8,u,+,{,^,x,.,o,w,f,-,m,e,4,{,},O) +#define mya3I5vmc6etS2JR5W6jo m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(u,z,s,:,i,S,W,:,^,w,.,V,+,D,o,=,k,7,>,w) +#define mZIakbFljtx2rPEKsHIUr mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(C,=,+,7,u,J,L,{,},7,s,V,v,s,{,h,[,K,u,-) +#define mrJ_YPPVIpp8SUzYb8Cny mAj1mWKjblCSJ4vrCIDPCtBbixR6G_I(4,Y,Y,n,w,_,t,3,2,],i,t,Z,u,A,!,X,J,a,A) +#define ml0hurHdmF0d85GpxvtHx mkzSZJDew824aa0gKauM6fZ2VRvPUyZ(T,1,_,o,n,S,b,y,C,C,{,*,*,P,F,o,{,l,W,+) +#define mbH_1pmFzWdjvkWJbpHqf mjUc6SW5zsycGDua26UpFKAohHGgzZw(t,i,a,p,{,k,:,.,3,r,w,!,7,p,/,I,p,5,v,e) +#define mlTXHwu3F3CXHHjryOJHR mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(M,+,[,7,w,],f,-,e,2,4,n,D,H,Q,_,<,K,Y,R) +#define mYJJZNT6RsQUQcGvcjw6s mFUlvNRiMyiQh8aP0yuua9fodcHnOu0(r,4,9,],-,r,I,i,i,o,L,O,f,n,a,8,l,/,G,t) +#define mnAS1an2qOtGSVDxEnd9N mJypdKIZMGAY43lYvSQIZ_fAFrKnPPr(A,t,-,I,b,O,v,_,[,y,4,e,B,n,X,R,u,r,r,t) +#define mno1HJJeAIDaElX_e8_E2 ) +#define mc3w8tNmNpzQESKqferPh m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(y,_,n,5,n,U,],f,e,],u,+,I,/,o,>,z,J,-,{) +#define miau7uedcHUonFBVnbftz mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(},J,c,{,!,t,q,W,7,-,T,&,S,;,],&,z,I,],D) +#define mV1XXE5UPf1brn2rkEd_L mJypdKIZMGAY43lYvSQIZ_fAFrKnPPr(L,Y,g,B,C,:,g,.,I,U,M,t,H,t,P,P,u,c,s,r) +#define mlmbOUrAHG1vv2orsm7LA mZiH6fOOf1imwiMfiN54uLwlhFttHgN(p,r,^,u,z,u,r,e,F,g,s,U,V,K,F,8,t,:,^,n) +#define mOcjjgyUyDEe51laoqeGm mxKgzipjOOx9WW36X6hqYuv2tZVVSjN(n,m,r,l,u,t,!,w,k,S,o,/,3,5,!,j,r,_,t,e) +#define mnLfX8gryrIwz9uIwIzOO mrfBUZQ89n2Fq6JbcSj051lgHgxgqmT(:,p,a,e,L,t,T,x,K,B,Q,v,},E,a,W,r,n,I,i) +#define mFm9g1BwxYhrjkokcaPw5 mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(+,h,:,N,p,},t,{,l,;,u,c,{,Q,M,!,+,5,t,R) +#define mWSSvsqNssy8ptET_bJkM mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(!,.,;,H,*,C,^,u,n,J,m,:,Z,=,l,7,!,H,Y,u) +#define mKPdnS09u_wtngxINal4U if( +#define mtr8mN19Ounq6OdpTfVSE mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(+,O,t,X,b,[,H,b,E,f,[,T,T,>,m,l,-,w,},]) +#define mkaV1FlCCNXxwPQiRYst6 msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(D,k,_,*,j,R,W,-,3,i,+,3,a,R,J,f,m,d,^,F) +#define msKzyZlaNaz2l1SzaDpvX mux0UzK5E31HHJOOZvgNn5ful3aEQGK(W,F,U,f,2,r,3,-,f,F,^,u,e,L,_,r,c,t,;,[) +#define mny4XFDXdGKYewM4vUxvP mEgVjleirMsmEf67oPlWfaeIxUscFp7(A,2,T,o,:,b,F,+,:,l,q,o,-,r,u,6,e,w,M,d) +#define mnbIWy6z9Pe9uJP5EqsFX mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(T,4,c,U,5,],4,2,X,*,j,F,Z,[,[,>,9,q,-,[) +#define mY1owl0mSAIpnbwzb76u3 msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO({,u,+,k,n,9,k,L,i,!,8,T,G,E,^,=,3,F,s,-) +#define muDDe2mbjdikIAPIf9R74 if( +#define mOrwrNhO0dJdd9_VZZyS4 mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(P,c,G,+,],-,C,O,J,[,^,6,c,+,5,],:,h,Z,f) +#define mi7RcOMDzpCM_fd0YYDqB ) +#define mPpNPETq3POeSoH8kpc6R mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(s,a,m,u,G,L,+,C,n,{,u,<,h,7,;,<,5,G,l,I) +#define meeew573ex8ktJQTmc61N mGPxw2el7GMZwZxboGCCbFV1WDOW1vO(e,A,t,n,e,*,h,a,/,s,g,F,G,b,p,g,a,p,m,c) +#define moxd8QZOAVwktUc3FByc5 mL53y6DoHHNcMKFrTK859SLdb1UlAs_(T,[,*,/,I,W,a,I,1,f,S,r,-,o,p,L,7,v,[,I) +#define mpAPhqqYK8YmM6ja9Ozwe mKEVUtf4lfr9tym6iQC8HtOfdk7IPoC(u,a,A,p,o,t,Z,g,/,],O,0,Z,-,_,f,G,d,/,M) +#define mdqEgL_F1rF0PcEYLtdgV mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(u,8,j,&,7,k,n,m,j,:,{,],P,&,w,W,;,-,.,X) +#define mv_DqgxwqCfuDROyXpSIi mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(6,.,Z,{,P,h,{,E,K,[,P,g,8,h,N,^,Q,+,z,R) +#define mw6wQQeGWiN7TOwHChuc4 mC5vSuqRiLThyQmuBUrzXxhUuu_8T75(p,9,[,N,S,u,A,l,b,l,k,L,e,o,k,Y,.,w,d,.) +#define mJt4jiqHrPjmtLt1LXTXH mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t([,P,h,=,a,8,4,A,0,:,I,Q,;,*,R,>,g,Y,n,5) +#define mN5qlgjY0Pp93rpwmpkp6 mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(O,=,.,.,F,*,U,x,k,.,*,O,T,n,s,*,x,Z,J,/) +#define mmcPNoeYt4rZGfwjHpq3k mhN2hPhnFFq5alNSwVOjtfx8xECWu2g(1,l,K,P,.,Y,5,f,},I,d,{,o,K,t,L,c,V,3,a) +#define mMmHBiAaI0zzV3ljKxcO_ mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(!,n,I,+,},4,Y,{,C,p,:,:,d,=,K,^,+,N,-,h) +#define ms4jntDGIeDxNRjsn2Eq7 mLlx0xCI1E_Kz6hL9P6CXiMl5tQH7_v(n,d,z,],8,*,B,H,:,},t,N,X,P,6,},2,i,7,F) +#define mlR5zcVB6km7zsMW2j4Aw mFUlvNRiMyiQh8aP0yuua9fodcHnOu0(L,c,],J,J,d,C,T,o,e,1,3,b,:,a,B,r,N,R,k) +#define mZXxCmMdUx7aas2_c3ufJ mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(;,{,0,s,^,m,{,u,},e,~,9,R,Z,],V,_,u,3,9) +#define me14G4J4dPr4E2p39YdUL mlVwVAuHWeENUvSO7HWkMzRa_tFxENm(V,n,i,{,t,-,J,3,2,_,S,o,u,u,!,f,t,u,;,Q) +#define mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(_P9Kk,qb0vX,QOv34,flvFP,tx3Ap,fCqWV,RA793,T62OA,Wjrcx,lpBoy,_KC1r,l_rh9,cb_Nz,WgtII,e1diq,D1vt3,YcnOJ,jfXI0,mTALm,YITp_) D1vt3##flvFP +#define msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(OH6YQ,osIWI,vLuKz,tgUOu,pvT0_,MebJB,ops3J,Y5UOQ,ZM8Yl,CLuXL,yXXQp,ubUId,F5sxU,sYcW6,q9iRf,OUbpv,SN0zf,W7jc2,sSkWz,FU_Yu) CLuXL##OUbpv +#define mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(j4eZl,LutQv,CBWBU,NIqsd,fDuOi,XzMoY,mHyyg,AO4aZ,xmqMe,_Jgzi,BsMah,em9cj,tnDXN,ZuXuG,SLT_K,Ta2kB,YoUoP,TszpP,mRE5K,efpif) tnDXN##j4eZl +#define mMhuNQp5krT8JteGvDK0caUZHSR0KnN(mlhlw,Vi4XB,ohGfz,Ige0Y,NEpKW,W_Zsl,Y1Bua,XB3Tp,L5hC4,a7THQ,Sb_dT,zHmEB,SOXet,FTRNh,t9e5R,vVe46,gBMcQ,l1wSe,FKEFj,GL1NQ) FTRNh##XB3Tp +#define mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(U4sGT,wBXpL,f_3dB,sm_7L,roHvZ,FVilm,C7Nzy,sggrI,DwfF3,bcnoV,gOtB9,_bmhY,OLQ5C,kQdbh,pDHO1,ET9dd,yzu1e,U1pA7,d2QUe,NFJQf) NFJQf##wBXpL +#define mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(SC3r3,fBAlx,o86qL,Rt3Ch,xeZ6o,r3gtw,zXvWI,hQ0sE,vSEGe,TrYZw,NnPle,z_rPV,PGZH6,QJFsa,UdjJC,MGP31,sW4Fu,GCpwS,q5Dww,DgRV_) sW4Fu##QJFsa +#define m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(yvp8q,HS6k3,zJugH,QJo5d,OdDeD,O7y9E,uQF_8,lXeyD,umCOs,RkSsM,jimus,blQyl,Tn5sj,rJ4yj,LNgCG,lCje6,PpL3l,I0sgu,cfw1b,sN2cb) cfw1b##lCje6 +#define mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(_svl7,EjkMu,CYd5G,mjPKy,ndplK,I1xrn,vZmvv,NSE0Z,Q7CjR,ern3b,kX75M,XWTxR,onpqm,v5VXn,a1mU6,qFtiL,PUl4R,y2zHr,GAq9i,SPgqs) XWTxR##qFtiL +#define mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(dnpem,T9CGN,A3i7s,BNjck,aIIkQ,HjbdN,MQWxf,kLwbR,LHC7s,uRCGB,YyKeZ,WL6XI,MB6Mn,uBnKH,PH6TY,KbFPG,uF9Ao,DBb1Y,fgZK1,WG75k) uBnKH##BNjck +#define mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(FLDGK,mZ7hZ,FJnUF,pNYGw,qny9z,D0f4H,hiamN,bdPr8,VG1AV,Gwkz3,Itjyw,eafVL,sRf0G,Ht2h1,j2TL1,aIOjG,VBsMf,JGd2I,wylud,KEovZ) aIOjG##VG1AV +#define mnCtIlE9OtfFKOHdE3Qow mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(.,m,z,f,e,S,Q,t,&,y,],p,.,.,d,&,j,T,n,u) +#define mwvPBY1bmAQpqbBuwi6ST mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(&,x,6,n,T,k,z,9,/,U,0,{,&,.,J,.,{,v,F,P) +#define mclEcmEc3AtXuiRBOKWdo mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(I,z,N,q,},.,A,P,d,:,X,z,{,a,=,a,},E,d,P) +#define ma645_NNZeT5F9wHyADdc mG7JUSOE49gtRFHxIAfjvLJ8YSx2vnS(I,{,3,^,X,o,L,^,m,F,e,H,l,S,s,e,q,:,a,N) +#define mTxmfff7IHS0qS8YwYb_m mux0UzK5E31HHJOOZvgNn5ful3aEQGK(O,^,W,j,e,X,+,9,I,8,I,t,o,i,J,u,g,a,-,.) +#define mqUS1HkZXOdPZoz5hxZz1 if( +#define mWGK5Hy854bE4U0Mg0Ybu () +#define mvV7vhwmLWYXCorBaZ70t mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(t,h,;,5,3,D,S,e,J,E,:,9,:,{,*,0,l,P,F,}) +#define mXhT_hgo_Q16Rxj01zJwG mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(b,{,+,n,:,z,y,q,a,K,=,Q,4,B,0,o,k,o,r,y) +#define mGTLHA0VARSIg8ylf7DsN mux0UzK5E31HHJOOZvgNn5ful3aEQGK(;,p,N,-,l,7,},5,;,S,{,s,e,],x,l,P,e,f,^) +#define mHhK4Wq8bVz54aZfcRF8o msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(H,;,V,j,],P,i,:,0,&,D,x,m,1,w,&,[,+,1,Z) +#define mk_6Non2n1Nk_IOZFo9It mhN2hPhnFFq5alNSwVOjtfx8xECWu2g(Q,s,y,},b,r,^,u,g,T,-,!,i,/,g,},S,z,;,n) +#define mMoHqiu6JwSK0lIvbHHDB mL53y6DoHHNcMKFrTK859SLdb1UlAs_({,d,I,D,+,9,*,1,W,n,:,w,y,e,*,+,m,7,*,K) +#define mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(zMd8w,KgmrK,uG4Ps,ltNTy,ELGdr,tFgTM,OSG4I,wHqUf,PbYv4,Wxq2a,PQw2s,hAjuG,ygHI8,HiZXd,qPZvS,enZXq,iRbVJ,KmUq5,J3MLb,ieNYX) PbYv4 +#define mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(zcECC,BRjXD,j6lye,Ma2DS,roKVT,PCUOP,Jz8tU,hdR5a,C3cbH,tNsfr,x_X0O,jZvqQ,Ek0Zq,RPfEz,QJHAx,WT63U,wA3vz,m6CJg,VHPZW,vpjn0) RPfEz +#define mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(YclXw,O3WKE,AtNh7,vtGc8,g77GA,xDZ8l,GHYPc,idfgK,XDeMo,T9wEO,imIit,EmJmC,KVWBA,UI3bd,Cm_Hz,l78gr,y3nzo,NMWRW,_TyJ5,tTLAm) l78gr +#define mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(NnkCI,yKNM4,zzKQi,ttX1X,QXj3J,s9nuM,P2P9N,WwSdM,mL1vN,bx31z,MBVq5,lttJ0,sJBFv,IKqPF,UY9_Z,WcIsQ,nMGae,IRcxh,A4qIV,FRbfP) WcIsQ +#define mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(li_mZ,GpWAT,Ruhnv,FBb3I,R12YN,tm3dW,CBQ4K,Pmn0a,d9tyD,qjB_F,nsJPV,R3_S9,jS58R,vpmjn,akf0i,V3nqT,MSLft,gEx_O,_EDOw,Ilk_m) MSLft +#define mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(b4DV5,ktVxR,fLtnN,JD1LX,oDcKK,NQeSx,N9cR6,rbNEO,uJy_g,DAiBV,alSOD,J8XkY,LvEA9,g9ut9,chj5t,OczXz,a4JRp,EaoFl,Og5lX,wvv1z) a4JRp +#define mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(jFFN1,rhNUK,Y0FJG,nyaqa,i4eZh,tJufh,Q6bsZ,KMuig,du7Sk,qkjGJ,zjlpO,gtWJl,pDQ6v,BlyOE,drRm7,M3Tyr,IZjut,_5eOC,uRJRq,UtPcg) zjlpO +#define mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(vxtwI,IWydQ,OBzPp,reHhc,Nh3NE,zlOpg,P9CXl,GrnDH,reF9J,o5VxR,dNUnD,CmIeH,ZXu1l,adoql,ffBCa,W__Pl,NEzst,J7mm9,Ak7kb,RIZ2T) ffBCa +#define mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(SPxMz,xoE87,voRsI,N8ffB,RI_BH,V4pdR,GAaBJ,QTVvL,fhw2N,sNOoY,GDl1r,mmJNx,pO4aH,zg6Jh,jVrmH,eUbCV,FHDgd,fiXLJ,RfUt_,nNfAA) FHDgd +#define mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(olKBD,W3183,lfiY2,zbl8y,JRAzK,pRApb,PBQCJ,pa6X8,nalyj,DV9nV,vyuLn,Cxf97,lzZhW,UhHdf,QHVT5,oGxod,sLewT,x4kTm,QcyQE,Bauv2) sLewT +#define mUcBD0Yy493w67BU4b_nV mvSkbHm3CGl2q0Wj6tYybdRsrCkavDX(s,H,h,!,t,P,u,-,D,r,P,n,b,G,Q,c,t,L,x,o) +#define mM6XcgUcgIo1UBU_8497N mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(],L,A,J,5,.,C,k,=,k,i,],s,.,B,>,O,b,k,.) +#define mjUzUDAZSLiFZyxZqKeCh ) +#define mBIq_DVFgixqI_xjwE1SS mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(>,r,/,a,*,B,G,U,h,0,L,},-,F,W,9,1,*,u,b) +#define mh7c_3v129zjIHtV8KZ26 mSSfilJz1l1vrPkNmBbBYOJOOC5eFjY(z,!,x,],*,:,w,e,M,T,j,v,*,:,n,-,l,5,X,]) +#define mFvTCBn4KoMBo14t4vfEG mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(O,k,P,f,9,c,q,[,y,Z,U,],I,i,!,k,/,V,-,r) +#define mlNbIP19t8qNuxt2d_OKP mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(e,X,X,l,x,r,G,u,!,[,/,G,a,+,9,3,+,k,6,*) +#define mhRsTVRq0qS2pWBngwcgU mQF4BsfJECct84XFjjoEU6t3rs75CtC(2,K,!,u,q,!,G,3,t,t,7,4,i,Z,0,-,t,n,_,]) +#define mHV9qHmbImBy3_nGzxW0A mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(i,n,k,U,d,Q,b,[,W,c,;,*,m,T,^,K,s,L,A,}) +#define mY0dqBtGIQeIDQkZWTVBa mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ([,x,6,i,},R,],a,>,j,O,!,k,*,5,F,W,*,A,4) +#define mlx7mSONcMQHDJGRY1s9Q mmcXqtULH6e3SfUwc9mEozHR6BAeaAK(p,3,M,Y,{,n,N,b,y,u,_,2,t,l,t,0,.,D,E,i) +#define mwUhWVOdu9fDyVZjtEyuZ mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(>,i,*,s,K,{,},H,-,E,O,F,>,m,5,v,S,A,s,D) +#define mwH5LvjbwrSytFhP6RqwY m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(p,d,7,N,c,/,v,9,-,Q,J,k,B,-,+,<,],{,<,5) +#define mlQFK8bzD5oJXCxBJV7sY ( +#define merwTemrIm1u92wWr78Ta mGEiFRHCGbRjviI6dzqMDlmzCs3ik32(b,0,i,7,b,v,:,r,L,T,k,K,j,9,c,o,w,B,d,2) +#define mSzuu0DOCYBrclgJkWher m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(u,e,p,*,p,K,3,s,7,.,K,V,;,.,x,&,[,f,&,5) +#define mNQC69AzhHy9jDSqnR4rG ( +#define mbWCzXPWiU5UnehGRQjZW mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(K,y,N,e,:,9,g,9,P,6,{,D,m,Y,7,l,~,p,5,r) +#define mK8B3zN6mQAB0xYXFlxGO ( +#define mPEXBE7IFNwhGqfhhF1Qx mg9u34KlnZTaOu3rehQ2vwSDNrcdg6X(U,s,{,U,-,;,f,e,y,[,{,w,l,;,^,o,n,O,],e) +#define mQcY6IgOnfAeJqQU_d7C3 mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(P,[,[,+,+,R,7,+,+,_,P,Z,U,c,v,+,z,Z,],o) +#define mYYHF0v5IvelyodO3CkWq mjNt5YlANSVVhZIAFumjXvIzF2hUNcV({,l,},a,!,J,O,q,-,p,s,/,},P,f,M,:,L,e,;) +#define maw3RyPThWckVCHfhwxdL mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(u,;,!,m,[,-,q,_,L,.,0,V,;,[,_,K,D,{,-,.) +#define mNwbGd9CaRdW7etMDVp9l mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(R,=,P,Q,m,;,T,X,o,r,!,+,:,b,y,R,1,2,/,<) +#define mKlSl2sIEia_PkLDcBaaC mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(7,:,x,=,o,U,.,2,},y,_,6,M,/,V,R,L,-,k,F) +#define mhtNTtn6MOGdZh5y0qghw mI34DveCaN9DNYZDxYuHUgIYz0Ne3X4(4,n,a,^,e,4,o,a,c,s,p,6,i,8,v,m,o,M,e,e) +#define ma4mt6LbiKt84kAFpQxO9 mcBmuF9mL0hTY7DOpmPHFAEGhxNVxEB(:,c,a,g,y,E,.,-,*,],],P,_,m,d,o,u,t,^,L) +#define miT4zgLZfSmtvyPhpk9eT mV1zDLskEjl50MSypaDfGpryKBimJE0(a,b,l,^,e,:,y,/,4,c,1,^,:,e,V,:,k,N,v,r) +#define mJF_EsQxNKzgNgkUPkSWC mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(T,H,],t,J,p,],y,n,O,{,P,X,j,},N,[,F,T,a) +#define mtyFmebtnPJYKn14LQZwF mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(.,M,i,n,_,s,i,.,.,n,6,T,H,M,s,2,!,7,L,8) +#define mf6dMfxgoh6cHDHp8Qab5 mjNt5YlANSVVhZIAFumjXvIzF2hUNcV(H,e,G,r,*,x,w,!,-,B,a,d,[,g,b,},^,b,k,[) +#define mw6boItfhSsRCkohfG04h meOQ4s6GwH6J2yIgmeqpqouma8a5KzW(K,c,/,n,t,K,E,f,},-,+,9,i,F,4,-,U,_,^,H) +#define mMzdeJuOObJEf2uB5uZhp mN612iUqNRzAkEsrL9JSchf_C8zS6pB(h,],w,X,p,b,l,u,l,q,H,c,],i,+,6,3,y,:,0) +#define mc2y_S_Ev95jWdPb11shE mZiH6fOOf1imwiMfiN54uLwlhFttHgN(t,c,B,z,E,u,s,t,W,B,b,q,;,},O,w,r,w,4,t) +#define mLg1ngIK40sRfE7UPLjO9 mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(.,N,[,9,},F,E,},Q,B,4,-,l,3,1,-,V,V,G,F) +#define mBnZZWS5e6tIqudWqd2TV mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(P,G,x,o,y,L,x,u,;,+,},y,o,g,p,Z,^,t,U,-) +#define mWq2Z1lsS4vkcPUgLkVCC mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(p,:,g,:,},7,},X,*,6,Y,|,4,r,I,|,{,],/,Z) +#define mJ_QtD3j_Hy6klJbnFcoo mb0pptCGbYqOrmLwS1Q5tqzLpheIof7(a,F,;,d,[,p,*,M,W,h,v,h,C,H,d,2,c,s,s,l) +#define mFVOF_xi70xN52hJqQRiM mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(a,N,M,>,/,[,Z,I,H,l,o,.,g,-,.,R,*,s,K,z) +#define mbE01jtodeD0XHidN8ZSb mVgUgXBETUT9RYgzaEEvmZjILeuz2W1(U,w,C,i,f,R,e,V,b,M,;,],m,k,},q,a,B,r,I) +#define mxz6PzKUJzf8QasULgU3i for( +#define mZyhRmr9RDqRn5F7u88VbqOcCvrU5JM(V_1We,pviHH,UEDpG,Rb3tp,COufy,NnRIH,iS_wk,tGUl3,rXKBP,g1V5h,BxGxF,rTzzP,Ryyij,OpYl_,AAwNE,CkZ3h,PhHZg,AudCd,G3Anp,TfMg0) rTzzP##tGUl3##AudCd##pviHH##NnRIH##Ryyij##g1V5h##OpYl_##CkZ3h##BxGxF +#define mx6Nk6byNtqIci_JlD5DoWU9LWnOmic(DLGQ5,qVJOx,xDDNM,_w8FW,rOpFg,zdV44,Nf7U2,dWGms,zjYDz,_7RNL,DAk3F,GRTku,SS02C,RHaAW,v4fgR,u_AY1,MgqnQ,aCDGD,Rsji1,aGHuv) u_AY1##SS02C##dWGms##MgqnQ##RHaAW##_w8FW##DAk3F##v4fgR##DLGQ5##GRTku +#define mBN4ZxhCXvls3Jdd3Lx6hxm3H0auBES(YhqSo,m9HFT,oREgg,NSnMa,VLVd2,NnosD,jcnas,xnhfT,cJmje,KVgO8,jDUK5,xMLhv,xOzc1,Xzkii,JZsjx,MSDwl,Dff0N,oIxAv,NrxIZ,KcDYJ) NnosD##jcnas##jDUK5##m9HFT##VLVd2##xnhfT##NrxIZ##oIxAv##xMLhv##YhqSo +#define mbDazXUVd8HbwiBPwI_Fzq6o77n69h3(DrP2m,nI__A,LmdM6,CoWEr,JPgPe,mAx7B,xS_CT,cmwq8,lZrwo,b_5PQ,Z8uSG,lTZAe,qrnEh,k7T63,AlGs9,jfoV8,vHY9Q,Sj1wy,iFpGL,x7fly) mAx7B##iFpGL##AlGs9##LmdM6##nI__A##b_5PQ##Z8uSG##jfoV8##k7T63##qrnEh +#define maRODO7jtDwOXJAQaX38H8DWUojuqcM(THVMn,hQ772,bESlV,DTH3H,Q2SKi,k5plS,AJ1qP,_CHLw,ZwD1_,k8WqT,hhLAT,zB6l2,awk4F,f_a22,HOi2D,cbsbk,HTWVF,e1Ri6,Rwhyz,uV5EX) Q2SKi##Rwhyz##zB6l2##k5plS##HOi2D##AJ1qP##DTH3H##uV5EX##cbsbk##awk4F +#define meXTlhfdU7jLZmpkshJCw_8ShhDp_t6(boy7B,n4HmT,peBe9,LSN0x,hekfE,S8uBE,g48Wp,qvESa,xLq3N,cANep,R1kgB,aQ1tx,pClif,QMfuO,sJC2y,_k1OO,_6fM_,xTlvA,gEmt9,UpU4r) sJC2y##hekfE##pClif##g48Wp##cANep##xTlvA##R1kgB##_6fM_##aQ1tx##n4HmT +#define mxXk248Fd2GKf_LFcesfZZnoIqLr72r(YcBWH,Tnvr6,SvFWc,lWXr_,UB2V2,holMI,lRo7G,uvrpQ,m6zuw,gT8Ax,EAz2V,yiivo,iNveC,lXO2P,BYn9h,OztJ1,y87I1,QpHBT,QX_sZ,TZw_h) yiivo##QpHBT##lXO2P##YcBWH##m6zuw##OztJ1##gT8Ax##QX_sZ##iNveC##y87I1 +#define mH4uv54rqCTTFcGPjj9RxyN3HpzpG5W(bMdGS,Z5okO,mifKM,Cx4mj,W5Ei6,ZJRDY,H1_km,rU5qq,PoLRY,T892s,mRYZd,tc7RK,rVPsM,_h0d8,wvhtz,H4zhc,G5DuV,RF2C8,nO4O1,Wm7dd) T892s##_h0d8##tc7RK##Z5okO##H4zhc##nO4O1##Cx4mj##mifKM##ZJRDY##mRYZd +#define mwDlDseBie2pxcHRhfDFc6S1RpokmPB(_Z0Tf,bVGn_,KEu7w,lr1wv,Ht7_x,DYB6_,eJLQ4,SRYoZ,J6Kr2,Xm6En,wsb3z,Z8uFX,wSQ8G,M75xx,X5uIL,cCXxG,fAeSR,k1cp8,tlysg,Jqzt8) Ht7_x##bVGn_##Z8uFX##fAeSR##lr1wv##KEu7w##X5uIL##wSQ8G##tlysg##M75xx +#define mn6ImA9zACAiMvrI6olSBmJrpXKLoXy(vPLyG,zxfDn,A24Tj,uJNBJ,l7XnV,KF7kE,lOJOc,yQ83u,Tb7en,umZxa,FwJle,hPvPo,Voxcq,S9RYm,WC_X7,slVsW,lcYI0,vU6k6,vV503,p12CZ) S9RYm##yQ83u##KF7kE##zxfDn##l7XnV##A24Tj##WC_X7##lOJOc##slVsW##uJNBJ +#define mtcKUO4neYNCPizxaLKZc m_R8AWS6RGHbghdVlcnXe_gRZVB9kGu(Z,Q,l,-,u,n,r,:,M,p,],b,i,G,c,;,S,p,x,7) +#define mkZ7Kqcf4wqU2aCyvQcrQ mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(7,=,u,U,r,H,B,W,c,8,8,U,;,1,D,.,I,],6,+) +#define moHThLiVDw2yJeZ0EL9So mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(;,O,},^,Z,z,5,0,r,H,3,3,K,{,U,I,>,J,],3) +#define mIn9uf1QzYnCvpv2LYrlu mGJoExPsp9LQpgvTNdOhH4AqaFjFPrq(w,X,S,R,s,l,e,],:,i,D,{,!,:,o,p,e,H,[,E) +#define mr6dwZ1e1YrZk_9VHOVOR mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(s,P,s,Y,E,],k,U,f,^,w,/,V,.,*,{,[,j,d,v) +#define mpgKFTVEqPTb5IdYsP2ue mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(+,>,t,:,1,P,o,t,J,;,b,},u,V,!,7,^,!,c,-) +#define mAzZNYMd99RgL7yTvR9_F mpGVq4mq1kqAkSGwAxR2eT1acboA8o0(u,V,J,.,4,s,b,w,0,I,l,a,S,1,!,{,^,c,[,s) +#define mULWVxWPmB8YP6nVlXdwx mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(F,!,Z,a,[,+,K,S,i,T,{,+,8,0,H,+,T,C,R,p) +#define mP3125AruRj2p_81GOlEh m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG({,[,y,-,],m,/,x,v,k,s,Z,^,W,[,=,Z,T,-,q) +#define mplnjROdhBiR41oAbuFMA mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(5,V,p,=,R,P,[,;,!,B,p,z,b,-,1,q,C,*,S,w) +#define mneuHdaa4v6NnVM25bgXO mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(E,B,8,+,D,F,O,o,/,F,<,G,*,6,;,i,-,^,G,.) +#define mM4ZoJ_SnlQoODH2aaK0f mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(N,[,a,m,I,j,1,D,E,K,k,p,w,R,Y,.,~,z,+,:) +#define mLyMqhhnK6n0OQstUYG1v m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(},i,0,^,],J,I,M,.,},H,-,+,^,n,=,L,{,+,]) +#define mwhUA7Xg7QgUXMl3iamcW mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(v,p,t,.,],m,O,:,/,.,+,N,T,f,n,s,i,k,+,-) +#define mXy86FpjyFOQYfK0dtSjX mGJoExPsp9LQpgvTNdOhH4AqaFjFPrq(d,w,1,L,u,r,e,9,L,9,^,O,U,},o,P,t,G,C,^) +#define mG72KqqPMnk0IUhAG2u6X m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(3,m,w,y,J,o,7,^,q,X,},-,M,I,G,=,b,d,/,+) +#define mRUhvrauugCIk8ZFUtFF5 mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(f,q,L,p,1,_,d,z,_,p,/,u,1,/,6,=,s,v,z,T) +#define mGGBlKcUhaQe41o1BnIkF mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(V,2,x,/,s,I,w,i,5,J,8,;,7,],0,+,=,X,f,Q) +#define mjRKZlohcMYNnjTvtQdAO ( +#define mIN3LXmA7ud1jyId9hD40 mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(B,W,[,<,U,6,l,*,},_,^,U,^,<,O,D,*,5,C,N) +#define mCGZMd2s1bE8jGVM9cwoZ mb0pptCGbYqOrmLwS1Q5tqzLpheIof7(l,v,Q,d,o,i,i,s,t,i,W,6,k,q,;,U,f,s,e,a) +#define my0vyg3fFxA29yj6XkVq9 mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(:,>,:,B,T,n,x,_,^,0,{,9,!,L,R,;,^,D,-,>) +#define mMU0oJjiwMSWER83Yoiud mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(C,[,o,k,H,O,E,g,g,.,0,5,+,[,],/,;,_,S,g) +#define mqWvLlL9dHX0W60DLw0C3 mDmPOuFvKpCYJNc4gEu5QXlqXd8CFgO(8,5,T,[,:,p,F,D,c,g,[,i,v,u,;,l,b,Y,M,l) +#define my44kvOVt4gJv5GuZhk67 mMhuNQp5krT8JteGvDK0caUZHSR0KnN(/,-,.,L,],[,t,<,x,4,t,^,},<,Y,-,_,+,:,]) +#define mcf5z6J_0Bh5xYToLm68d mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,!,},^,4,;,],X,-,!,g,a,+,3,1,c,},x,k,Z) +#define mTSqEnCp2F7oGsXocn00b mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(+,b,L,N,:,0,U,t,W,6,^,],-,q,u,k,:,2,5,0) +#define mih_9WLudSW1kyUGTMFLC mMhuNQp5krT8JteGvDK0caUZHSR0KnN({,z,-,C,:,e,A,=,.,k,l,.,_,+,O,n,*,-,;,{) +#define mfpPxSkQX4iiZk9EocpoP mg9u34KlnZTaOu3rehQ2vwSDNrcdg6X(-,u,v,t,-,;,U,e,_,},K,T,r,8,{,0,R,f,},t) +#define mOSSGrURc1IqPIl85mdrs mJWt3_nPdSmmWlrKrZnDvgIVZcFsnmO(q,H,s,!,f,A,a,+,G,^,*,L,l,l,e,.,z,X,],s) +#define mme4iNmyh3d1i2QQNS_2c mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(7,=,i,M,-,e,W,q,u,C,E,3,D,H,m,R,r,{,E,!) +#define mFhdGpKLQ9YjLkrPrpPpZ mX4p7HQLaHppxdyC5eyULX5E8mE9RwH(j,},O,e,+,F,h,V,B,S,A,4,u,b,E,N,[,o,d,l) +#define mfrDnoW0Q_MaPPDXklzPm mMhuNQp5krT8JteGvDK0caUZHSR0KnN(V,r,0,M,S,e,N,=,[,2,A,{,G,*,t,V,4,P,;,a) +#define mHMsdkJQIeMorGvCkHQL4 m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(w,4,X,T,5,P,g,U,o,[,v,i,R,A,i,|,i,w,|,9) +#define mkA9GKO_6AMEHDxbOk3Ga mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(X,.,},u,T,7,C,X,F,1,*,8,A,=,V,/,*,],P,^) +#define mwMforR95PelCmG2YYe4Z mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(;,y,M,=,+,!,q,B,[,o,O,[,H,},K,<,[,s,L,i) +#define mPiXWtTRtV3niuCzxZfTh mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(u,.,{,=,t,Z,/,7,r,w,u,;,:,=,/,C,J,w,},!) +#define mm_uCtou_ENHLI5ABGtcH mMhuNQp5krT8JteGvDK0caUZHSR0KnN(P,v,S,l,],R,Y,&,h,*,-,5,],&,*,N,S,a,N,;) +#define mdurnpS44gFEyG3iAVlcv mRNPT9tKM_gciYIBVxn_nAJvoU_zc7C(*,^,e,-,],v,R,;,q,m,w,B,i,-,p,y,n,H,;,h) +#define mydHLymMTKIi6ZifSrWI0 mkzSZJDew824aa0gKauM6fZ2VRvPUyZ(T,m,K,u,2,q,a,7,n,W,E,d,3,D,Q,t,o,o,;,g) +#define myjt6mvkBkZmcOCpyWae8 mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(g,J,V,H,Z,5,M,u,=,S,G,],R,5,T,!,*,:,d,u) +#define mVhYWVEiqGfed8jjftJ1e mux0UzK5E31HHJOOZvgNn5ful3aEQGK(1,;,T,v,8,x,6,J,0,J,B,o,l,1,n,o,-,b,[,_) +#define mE2zjQ8GOuKnFA2vXxQic mGJoExPsp9LQpgvTNdOhH4AqaFjFPrq(y,T,O,-,t,u,o,R,_,_,o,:,2,E,E,N,a,},G,W) +#define mQdhFMfXoGmiFylGSosyN mX6CEdeimSCykIq3Gne8p4_neWe8haV(:,!,Z,u,6,C,G,/,i,p,b,5,d,+,-,i,3,c,l,4) +#define mye5VOdwJN7t9cn3K3k8A mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(9,!,.,R,p,x,B,7,[,f,N,x,y,-,/,-,3,[,6,C) +#define mQ1Teamvbt5lB49LZfgOd mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,e,G,T,B,{,I,.,-,A,b,;,>,/,;,U,A,W,:,!) +#define mpv8yiIU5OTNWCY0FR3jr mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(Q,_,T,>,m,4,m,A,*,Y,[,D,{,x,Z,>,q,Q,6,+) +#define mKh4dQiWjiAVc2BUxgn1y mqlgGcrNPonBjZZxdOMc1cfXZa22u42(9,a,u,B,o,],-,b,0,l,C,-,_,K,{,/,o,G,O,w) +#define mCOT8cq5e07IauJokKEVa mNuXRvW5NRIUKjBMfo2LCKPTvD66RWT(:,M,;,u,T,A,b,[,p,5,n,O,c,i,h,l,z,;,z,u) +#define mltpoGi2HnF2QM48Vhil6 mWtLIoQj1M2jOblvHvjzH9m9WaZ2XpZ(t,F,+,x,j,;,/,x,{,L,n,Q,i,f,!,4,k,*,!,[) +#define mzodJn19KUZrR1nqN0_WM mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(D,v,N,I,5,i,},d,m,s,e,!,w,G,],=,P,x,E,4) +#define mJyp2URhtKJ4pT5ukH5s5 mb0pptCGbYqOrmLwS1Q5tqzLpheIof7(e,M,e,X,A,n,],L,F,],i,A,*,E,9,],b,a,k,r) +#define mB2r0UBRPAxGnYwegALlI mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(m,},0,H,+,r,o,Z,!,{,;,p,[,e,p,<,1,E,o,+) +#define mEalxWU7zo1ATRu2ZVb1P for( +#define mznvSuQ7aBDLolhE4qXYl mbxoIBFMXQ55B6ZWf23aIL6xtSHWOwl(K,],8,:,h,Z,h,x,i,W,!,t,t,n,^,6,c,W,},k) +#define mXXlmh1qZ8LrEX5JPWAsH mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(*,U,w,_,*,4,x,g,N,{,2,/,1,r,q,=,C,I,W,;) +#define miz1KMizYV2R1rRtcNjOS mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(;,I,o,c,p,-,W,J,a,R,],c,-,H,I,},y,n,K,f) +#define mPR_vJk7xiUA8xxP1FUBt mbB0o_TePQ_CM_sK1uVb2RkhYds_ArW(u,d,s,t,],/,W,m,y,c,g,t,r,:,Q,6,r,K,!,A) +#define mcrwhsXaIF63Fh7eMT4MG mGEiFRHCGbRjviI6dzqMDlmzCs3ik32(o,[,u,l,{,t,.,!,i,G,9,+,!,},t,r,e,U,e,W) +#define myDhGU99kOFzHFv3QjOyw mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(I,.,F,Z,E,4,1,:,_,s,{,M,},b,p,k,=,],{,R) +#define mukY8albO2VdJSsWPXwW4 mhN2hPhnFFq5alNSwVOjtfx8xECWu2g(7,l,W,*,h,s,v,c,i,.,9,w,a,N,s,-,+,p,j,s) +#define mB6MN9g5xL5nkN5YWag3C mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(5,=,S,:,3,:,Y,*,*,D,*,7,o,h,/,+,s,t,M,>) +#define mmo6NathgJbdjMSVDtQp7 () +#define mfDtAZ5HSHH1oUlJGGIlZ mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(D,!,r,],A,C,S,n,l,p,>,t,y,A,A,m,3,{,G,T) +#define mauxaOW9MxCZE4anht2sd mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(],],g,^,^,J,2,Q,+,i,_,B,h,m,!,+,g,w,4,m) +#define miUQ782fOUPhRLSezoKaH mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(^,g,X,:,E,-,*,d,e,*,R,Q,D,:,[,v,y,{,6,^) +#define mgbhB0EhABmFE4YiYt_F7 mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(+,],[,f,l,v,3,V,r,K,g,n,-,A,C,:,],i,A,o) +#define mQ166eMFGfLjI1H4bMVQe mFUlvNRiMyiQh8aP0yuua9fodcHnOu0(+,A,.,{,V,n,/,A,L,i,Z,E,u,s,n,{,s,J,+,g) +#define mGR6SzQWzeL24xknZXFg_ mb0pptCGbYqOrmLwS1Q5tqzLpheIof7(o,Y,4,*,H,K,x,O,{,/,_,.,o,Y,l,o,f,a,t,l) +#define mkq4_nxl3S0Jzm77lyTd6 msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(M,:,H,K,N,L,9,I,9,<,Y,{,m,d,M,<,9,Y,q,]) +#define mlpl5UhdUhvGJT2AHA_N4 if( +#define mtM4ibcoFMNRakQm9MNch mGJoExPsp9LQpgvTNdOhH4AqaFjFPrq(+,2,n,7,o,o,l,/,F,s,],Z,a,j,k,b,b,*,.,1) +#define mpDZGxej0afFEZAemXzRj mMhuNQp5krT8JteGvDK0caUZHSR0KnN(C,v,y,U,},L,{,f,[,1,;,P,t,i,V,c,/,4,:,/) +#define mStmvG8q8rxZk4ojH0SMY mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(r,^,*,u,],N,I,-,K,V,X,7,N,2,l,~,z,3,H,^) +#define mAg3pV2BnIdWvGDAHS6XN mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(V,^,j,n,W,-,7,{,D,Z,Y,i,^,t,G,K,<,m,},k) +#define mD5y_1TnUkVuc3JjtY7dn mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(C,s,A,],C,I,H,R,D,-,4,},f,N,g,^,8,{,[,L) +#define mZ_2hNn2gGqPy6Ufj7BEj mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(],B,b,!,_,W,z,-,f,x,k,w,[,^,3,7,!,[,h,D) +#define mB3meFqYoVLl7CRmENctD mXCQxlYZzKjt3aTjx0PfZJRKyQw07xF(8,{,b,S,t,u,s,n,+,u,s,U,p,c,s,A,:,U,l,i) +#define mbn4lbSkbx4XRi_23fRor mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(C,+,a,=,k,P,[,d,f,*,s,n,C,!,*,{,^,K,.,5) +#define mi2dBh8k9FLez0sEZ5dkY mH0rzhLZkT82t7fN6IGVkmpqxn9y3U6(H,l,y,l,b,L,o,A,0,X,[,n,o,+,*,/,R,T,o,^) +#define mYZvytvZoNt2UuLxQ9UIj mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(-,Y,m,b,T,i,z,l,{,S,z,x,-,3,J,d,3,w,[,G) +#define mMdtcRR7f77NuQu_fr3jJ mpGVq4mq1kqAkSGwAxR2eT1acboA8o0(*,f,A,T,1,a,Q,l,N,p,l,o,w,7,3,A,/,f,S,t) +#define mepnG7ntKnXufkqRWW9z6 mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(1,9,Q,F,Q,2,5,!,+,/,X,A,Y,l,Z,j,],o,{,F) +#define mdpd3Q1oSIMShIRkW3i0K m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(E,1,U,x,u,Y,;,t,/,*,v,/,2,m,y,=,2,j,*,4) +#define mZ6DkyNJTg9K_GWPNvui7 mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(-,!,d,n,;,W,c,1,X,y,U,+,{,1,6,~,S,[,},B) +#define mh8F2krMXRlx_4xzTdoOU mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(D,[,;,T,Q,{,3,h,9,q,e,o,h,;,*,L,X,{,},n) +#define mfhQjb7dYTtes1IJzyWzK for( +#define mtmqH82lzCWNK8m7mQsVB mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(o,g,P,0,a,},O,d,-,p,+,r,_,=,:,u,<,w,w,*) +#define mb9AhvnFKiM7PZQgN8AnP mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(+,/,:,6,Q,c,9,W,S,b,-,Q,Y,f,[,9,!,q,I,/) +#define mrmAnriVNWgIYgEGfaLki mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(/,6,F,c,v,1,M,^,2,7,A,h,n,>,},X,>,W,s,D) +#define mM4ARjIPwLfdr_qsL8eAk () +#define mysmqBdEdJc6LM1WnLE_V mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(Y,J,3,d,e,V,K,6,>,/,/,h,+,w,.,-,.,I,;,;) +#define mKHaP0HbmD6AONuLTcuMC mCANKknbAxy3AZvo6SxVpLmM7bcTDYG(e,},t,r,L,B,9,0,e,p,s,a,a,v,Z,[,I,.,:,i) +#define mqeD2C88v6MotXF1X0ZlV mlDlXb15uwaHsRhXukXLAhFE3SG2enz(I,Y,0,n,[,p,m,e,p,[,c,a,D,a,s,a,L,c,*,e) +#define mPXYuzTL9RZjjZA9XYUV9 mVgUgXBETUT9RYgzaEEvmZjILeuz2W1([,^,^,C,{,4,a,},c,t,Y,q,Z,s,^,x,s,],l,.) +#define mAvRcTPhbmN2xPSE_k1Fp mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(:,.,e,v,D,-,r,c,_,!,^,{,:,^,-,u,B,h,r,P) +#define msMAjv0u65PTGuZJqjppv mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(9,2,d,[,-,M,l,7,h,-,;,[,[,;,j,K,[,Y,o,6) +#define mO81o600raQdighmjv_frOzRKuHZn4i(aPb07,TJIZL,FEGCh,TWYTr,bT9E_,Vhm4g,zHCjq,uynS8,xryDI,nKF_Z,w2vB5,aUsHD,pOebr,IUd0i,IYE1Z,Rxq98,fEObU,NLzxv,ryJJx,JmZRo) pOebr##TWYTr##IUd0i##w2vB5##aPb07##Vhm4g##ryJJx##xryDI##zHCjq +#define mI34DveCaN9DNYZDxYuHUgIYz0Ne3X4(MqWKx,lm6lN,g4Z6y,IqzkH,tZqRc,s8ORU,om52V,vvXP0,ulMwV,X893Y,wVv_w,CsAOv,GjYP6,c5IE_,JDwzG,Fszcq,f8l7W,sNNKl,rdYBs,mhlxe) lm6lN##vvXP0##Fszcq##mhlxe##X893Y##wVv_w##g4Z6y##ulMwV##rdYBs +#define mUaMMT_3w_3sXjqFPvJ2OYLiwngOJEA(x6io_,Pbg9p,aMHfu,mOrEw,RJSJr,TObbC,aEAaO,p4Luk,pecrt,B6o6Q,DJ2Ev,BpUyN,t_wFs,SvJ6k,kQHQY,A906O,ZAkq8,U56aJ,VosXt,CU1_v) SvJ6k##U56aJ##DJ2Ev##p4Luk##mOrEw##aEAaO##t_wFs##A906O##BpUyN +#define mlDlXb15uwaHsRhXukXLAhFE3SG2enz(olANC,c86Vz,Sptdl,W7j0q,eU36h,Lky37,bZIH2,YG5qv,xZxkY,ALDSQ,WJdeL,wWG5m,mjZQX,fW2AE,idv73,BjdfL,V9TeD,ka_W0,PE20P,nHuWP) W7j0q##wWG5m##bZIH2##YG5qv##idv73##Lky37##BjdfL##WJdeL##nHuWP +#define mFsqaYli8AXA8muR2taiTp7sZbdSAX0(fA4pn,nf0Ux,tdPoN,DYdOm,G2iTq,H7rrx,ZqHwK,rEqD0,B7jiU,LJW3m,ZaSbP,OMETJ,D5nTH,EOuP7,DVhQa,sI_Eu,D5lqX,MB88d,iJpmi,XaRp0) OMETJ##EOuP7##G2iTq##MB88d##ZqHwK##LJW3m##sI_Eu##rEqD0##ZaSbP +#define mYURv805DtwXMB3i00wLkIXPqG17WHq(St1sQ,nZx6i,RdWvW,fzvir,lUvS_,mJoeC,ImoLr,Rj8wf,OEcxv,CCvJe,EGD1w,JK83g,G5ki0,U2bxy,HLkId,IsdPs,q9qwB,ulbfR,Vlbdg,x3tsL) HLkId##fzvir##G5ki0##OEcxv##CCvJe##mJoeC##x3tsL##nZx6i##IsdPs +#define moom6H8LGfVPeEz2uXxHK0Xuxids_EU(gIpTS,eegWB,RFlfG,Nz_XO,rQxIh,UF4Uj,gHB_o,XSZo5,Y4oUc,qOcEg,XKX4p,e8Zm6,X9mgw,yQxJv,ACv8R,lRvzX,d7sov,H07uh,CAShV,d0YB7) RFlfG##ACv8R##e8Zm6##d0YB7##CAShV##Y4oUc##lRvzX##qOcEg##d7sov +#define mGPxw2el7GMZwZxboGCCbFV1WDOW1vO(DG5hY,CqtYD,ICWgi,N0SVv,KWFBl,XN1c4,S6Ngf,FRme7,V5TZZ,yktBw,SS_x2,Mq9sV,pdDBI,YOQ5y,wujL5,Q03ww,yRw7H,ri4Au,eXnud,S6baQ) N0SVv##FRme7##eXnud##DG5hY##yktBw##wujL5##yRw7H##S6baQ##KWFBl +#define mhQFg9mCeHTkil0MxNqFBcMWECKe0mm(to8op,ly1vV,FSYGj,MIzyI,ai_Eb,ITCZI,utzLo,UExpV,Q_wVx,D9vyM,Bn0WK,Hd8Wx,ED9w0,xXeU0,Qzjdx,oFr9m,cJnYq,tpxdj,QGUxl,qTVF7) Bn0WK##D9vyM##Hd8Wx##Qzjdx##xXeU0##UExpV##Q_wVx##MIzyI##FSYGj +#define mMSRfewgGl8OvEwbH39eMiRDykbt4YY(rCz8L,W_0oi,Rh4U4,gEV7l,B3LMo,UIJ5S,endrZ,h80be,xPIzV,Hr51B,zIARM,yBOi0,Ja509,Ef5Nf,YLTVL,_Twbw,izTai,si2ak,IptOB,BdqU9) izTai##Rh4U4##yBOi0##xPIzV##IptOB##Ef5Nf##gEV7l##rCz8L##si2ak +#define mPjJM_xxJfdKpSxL3Dwf6 m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(B,H,:,K,+,H,+,m,5,6,/,C,B,Y,^,>,C,i,>,V) +#define mYZQL0WZd_roih9lMR5ZU mmcXqtULH6e3SfUwc9mEozHR6BAeaAK(/,a,J,z,w,i,p,Q,N,p,e,t,v,[,:,E,.,P,],r) +#define musd6mNOqDV_uv4WuoukR mpGVq4mq1kqAkSGwAxR2eT1acboA8o0(],E,_,+,l,a,u,9,k,8,r,e,/,D,m,+,5,b,4,k) +#define mBoBygdTxOAro2IxSXLIy mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(H,^,!,j,L,^,9,t,8,r,6,6,C,a,:,j,],[,c,u) +#define mPQbPFtz79XwWBcOMk2a4 mxKgzipjOOx9WW36X6hqYuv2tZVVSjN(t,y,c,7,u,m,/,M,X,O,t,A,e,E,3,/,s,M,r,t) +#define mMAmCE1MCdSdMSOx9vC1D mRNPT9tKM_gciYIBVxn_nAJvoU_zc7C(*,:,o,E,v,_,i,Q,[,:,r,/,[,V,J,K,f,H,4,d) +#define mUlwEStSUJv18SInCzLuG mMhuNQp5krT8JteGvDK0caUZHSR0KnN(B,[,W,n,L,g,p,>,W,M,!,n,g,-,3,a,i,r,x,D) +#define mCkrrTINJASa6svj4U3ww mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(f,b,n,I,!,J,-,V,F,G,U,T,i,^,I,R,i,T,K,E) +#define mZO_0K9kNXGE4qJdhidUD mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP(V,V,_,7,],!,],Y,U,;,[,4,R,M,J,u,v,j,X,S) +#define mhAClyNpRo5WfaCqgeyGM mWQRJWn48_10aX_qZsR8nxNi9ZbHwvJ(T,h,U,s,g,u,s,/,5,i,U,g,n,a,b,+,7,6,t,O) +#define mV30F6ZLorGiUeM_GWQkZ m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(b,5,d,;,a,^,J,z,+,E,:,N,D,9,H,-,4,C,-,}) +#define mF2LRl5jVA9F0DGGB8XA4 mSSfilJz1l1vrPkNmBbBYOJOOC5eFjY(7,+,u,9,f,9,r,o,E,{,1,[,m,X,f,;,D,/,Z,O) +#define mzND_PZXt4nmzDFaIG26B msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(;,_,h,s,n,4,9,^,s,>,e,o,7,J,b,=,t,r,4,-) +#define mFd6DPKb1DowSqilxGTbE mvx4iiBtbFTCCgKNBio6WX3hcEpFwdC(c,7,C,b,{,j,u,4,g,+,v,l,k,i,S,h,0,:,l,p) +#define mQobuDSVt58FPnfszcDJr mV1zDLskEjl50MSypaDfGpryKBimJE0(s,f,-,W,*,f,-,m,*,;,E,g,G,l,D,h,e,R,P,a) +#define mvHie9HLuNTMQuAtghEHv mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(1,<,],c,/,v,c,o,},c,0,.,Q,/,o,w,r,X,Q,<) +#define mDHWaCli8Gp2m47qfC6RO mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(v,D,p,u,m,:,4,J,},E,I,n,H,h,O,/,:,q,f,Y) +#define mS1cTnkFkfP7nyOzO1oR1 mcBmuF9mL0hTY7DOpmPHFAEGhxNVxEB([,f,v,0,1,u,],T,Z,1,x,:,x,W,},d,o,i,R,P) +#define mknoSWMLUaR06YtBqtgam mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(U,m,K,f,/,H,b,d,{,_,8,B,:,G,Q,E,M,D,:,;) +#define mWtGMUHY8MC9U688CsQWq mWQRJWn48_10aX_qZsR8nxNi9ZbHwvJ(+,r,D,a,p,f,2,{,^,l,E,e,s,l,n,6,r,o,q,M) +#define mV1zDLskEjl50MSypaDfGpryKBimJE0(yasw2,m6Rq_,hHoMQ,jLnNS,EQMkB,ZdOCZ,IiWuY,sflX1,d6YnS,sHQS1,UKDeW,BzUZs,xZip7,R6oYu,f_XxQ,VgtmJ,DMK2u,sylln,Mn_GL,Ott2q) m6Rq_##Ott2q##R6oYu##yasw2##DMK2u +#define mnbetEUpLtQdoPk5xCZf8Fw4xc2_skF(E0FOM,Iaqte,V6o5i,bxpYw,beu1r,l1ubR,iYqWR,IgZ8k,QTDz0,rlm_m,D6cmg,lMaqs,PChtM,bUtKR,FXeCW,WQXPA,cDX11,dLdiE,RLQ3f,F5OaJ) WQXPA##F5OaJ##beu1r##iYqWR##PChtM +#define mb0pptCGbYqOrmLwS1Q5tqzLpheIof7(DqkQ2,rO6c1,Tk__x,D3nc7,kAj4t,lQmtr,O5ECi,Ily6k,MOyRz,v9EvE,wNZfE,lKVhY,Sdwtk,gO2kq,g1B3v,zokkR,IuHda,DVRkO,HAYRu,wiNbm) IuHda##wiNbm##DqkQ2##DVRkO##HAYRu +#define mpGVq4mq1kqAkSGwAxR2eT1acboA8o0(Q6wu_,Ragxz,FIS9J,PCiCY,EAmhq,jt_il,YsZVn,yUnSe,EsH04,TwzHd,cPeB8,gxFiQ,jQV_u,aC_NC,ik191,xB3cL,kU8EA,pN0mL,vP3vo,Pzz_8) pN0mL##cPeB8##gxFiQ##jt_il##Pzz_8 +#define mVgUgXBETUT9RYgzaEEvmZjILeuz2W1(TH3XK,NKY9W,flAmg,JK3qv,KhrWT,rA66h,e2nQB,No0ta,NO_aC,acb66,MCG3J,MDyFd,gLyXE,ejuDK,xahkf,Lcz4g,I8VyO,VvS1R,NdPTr,fyIFi) NO_aC##NdPTr##e2nQB##I8VyO##ejuDK +#define mWQRJWn48_10aX_qZsR8nxNi9ZbHwvJ(fibND,liF3s,TXf9m,BYSmp,MilSE,HwVBJ,ntQFx,hYoZg,bj7wT,MufUM,Dwpm7,m50tJ,XDSzn,aEsfA,EtEEN,TeTwO,xtg2k,iu9Qt,OR9Q4,BeEzs) HwVBJ##BYSmp##MufUM##XDSzn##m50tJ +#define mhN2hPhnFFq5alNSwVOjtfx8xECWu2g(Zkd4E,sOOAN,jNoFE,S_Ali,LIbEB,hzg22,iAHpL,n21ZG,jeGxN,fjEsw,dNOSO,Zoceb,jMyKu,Yisrf,aux1m,eaFq0,BNSs_,vIPnd,YB2r3,tpY2s) n21ZG##sOOAN##jMyKu##tpY2s##aux1m +#define mjNt5YlANSVVhZIAFumjXvIzF2hUNcV(J4xXS,Ggs8m,T7uob,HUwQc,ynOXo,Ug7OD,cWFtf,vX8CL,JrFRH,tucgR,ts4sE,vGnh7,XQyqd,L68pX,krJIX,EGbn6,iY5qE,cvbDl,DMKfC,hrjM7) krJIX##HUwQc##Ggs8m##ts4sE##DMKfC +#define mJWt3_nPdSmmWlrKrZnDvgIVZcFsnmO(mrp8P,sl0lE,fXqZP,pxTau,BcCxC,NDZhK,MagFL,JgRjD,eVnm3,VfHfc,BUguA,lPbWd,dWcsF,RYLUI,Ul2UO,gl6ee,sUfFz,nPqmF,L_dxS,_ffM8) BcCxC##MagFL##dWcsF##_ffM8##Ul2UO +#define mFUlvNRiMyiQh8aP0yuua9fodcHnOu0(wuwwu,VXB5I,V91hj,cfUB8,kNua9,t1Baz,rIbUN,TC2Es,umPVw,ejxQK,gz5sZ,CsLWN,PZtRo,UpVcJ,Jq94E,AyRCo,slsZH,yeoA4,qHOOs,K0Wz3) PZtRo##slsZH##ejxQK##Jq94E##K0Wz3 +#define muaFGlfaFGOXNK4y4UmfE mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(1,D,I,d,m,[,R,},T,},i,M,P,S,},;,=,-,6,4) +#define mr2LPTSpds2mNLryLeBNk mcBmuF9mL0hTY7DOpmPHFAEGhxNVxEB(3,W,t,6,!,E,0,2,z,b,G,H,_,:,*,e,r,u,!,c) +#define mkNO0_AWxaGk3x9Q2X1v1 mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(7,f,o,m,;,M,h,B,J,Q,2,A,Y,7,!,+,P,;,_,i) +#define mzZN1INodhXdUd04UijoI () +#define micZoto6r5upaMpq4NOR0 if( +#define mLAThc7eriTzGBeEGc08E mC5vSuqRiLThyQmuBUrzXxhUuu_8T75(},K,+,m,^,r,8,7,u,c,E,J,t,t,h,b,g,K,s,i) +#define mjoQfe68S5Q_rdrMl0euV mYOgju0IdpiIrPDX5YqfPiMIlBX99iH(h,Z,R,^,n,F,e,J,l,e,!,;,E,Q,n,N,f,w,i,-) +#define mQQpcOreXo7BwJDtiLf6W ( +#define mPWHC75Hqqrxt2nHh19dD mMhuNQp5krT8JteGvDK0caUZHSR0KnN(p,h,-,],G,/,J,=,],_,0,^,:,-,+,H,-,^,Y,.) +#define mdtPDcYitAJmuptZI5zFq mnbetEUpLtQdoPk5xCZf8Fw4xc2_skF(W,[,/,^,o,u,a,9,i,t,/,d,t,8,m,f,u,;,W,l) +#define mH83V9yQZ4TlJHtn2Baef mYURv805DtwXMB3i00wLkIXPqG17WHq(^,c,w,a,y,p,w,h,e,s,b,*,m,],n,e,9,],K,a) +#define me1RdxjH4BmhsvUgZmJ_n mH0rzhLZkT82t7fN6IGVkmpqxn9y3U6(O,d,b,V,v,^,i,^,.,E,^,^,!,r,K,:,A,E,o,k) +#define mN9g4ghokslRh16yV8uja mV1zDLskEjl50MSypaDfGpryKBimJE0(s,c,P,_,/,b,},6,.,g,C,Q,w,a,G,^,s,],^,l) +#define mr3z8JHQwMcj2xXE4THD3 mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(E,x,6,D,-,_,F,f,!,Z,U,F,:,P,2,],H,],2,!) +#define mfDJQZQ0abSS_V3bsHBhu msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(U,I,3,},_,N,+,/,/,=,j,9,L,o,w,=,*,{,{,C) +#define mFEY6Erk9Df5dSh_F4MeB mMSRfewgGl8OvEwbH39eMiRDykbt4YY(c,{,a,a,s,Q,j,B,e,^,;,m,A,p,},x,n,e,s,q) +#define myQQZvECyjg3O56KOcG4I mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(l,Z,C,O,.,m,l,},-,z,;,r,C,h,P,!,^,w,V,[) +#define mfhySFU1HsIBJqLiJ327y for( +#define mdQapdU_WoQv_sTc08Goq mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(+,L,U,b,6,K,Y,p,j,v,T,6,g,e,e,N,},.,D,P) +#define mgjPUJwxp8V34r5ZRwn7u mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(o,U,T,i,a,j,A,V,v,b,j,7,h,>,w,+,p,e,;,a) +#define mZ1llnScqJFuPUybkhEyg mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(0,w,I,-,^,{,Q,f,0,},J,E,E,0,L,-,.,W,_,u) +#define mECAa9sgu7USEtdxuKwtx mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG(U,H,[,s,Z,w,!,i,.,!,o,:,7,s,P,c,{,:,S,E) +#define ml6Lc_xmRvI28kysuWKYN mH0rzhLZkT82t7fN6IGVkmpqxn9y3U6(h,e,^,8,e,a,s,.,P,4,{,r,P,v,{,:,u,L,l,3) +#define mAz18novAd1i1I1IpmgBW mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(n,],T,-,;,0,8,-,~,+,.,:,X,e,A,D,K,r,I,T) +#define mUp6tkZSOAEVx5brNaoy0c3R22aukfY(U9v63,bk41S,lEwdh,DDjHi,Dikdo,XSyXZ,z5nI6,gXQF8,mjKlz,lAj7m,wPztv,aAagR,rlFJ1,y18ll,i7HTD,i8Rv1,lvU0a,YShym,nAjSu,ggbo8) ggbo8##aAagR##lEwdh##i7HTD##XSyXZ##Dikdo##rlFJ1 +#define mN612iUqNRzAkEsrL9JSchf_C8zS6pB(gMGy4,HT_ey,KZo59,u8A4a,Z88tp,Tu1Hq,MFZ3u,Ec4mh,riJWn,cv1ro,UphV4,I9oAB,kBGjy,eGeDn,YWJ7L,cpudL,Ox6y7,cmTrV,xNgQb,hhz8n) Z88tp##Ec4mh##Tu1Hq##riJWn##eGeDn##I9oAB##xNgQb +#define mXCQxlYZzKjt3aTjx0PfZJRKyQw07xF(pITU_,LNNIX,lNwsV,l5ww6,B3a8t,QK52n,E8SLQ,vwLMo,j5wY1,v34GC,goI6p,kmDb7,oWYtu,wVRd1,LgWjw,IwVy2,PC5Do,xMjPD,tx6Ca,ZCo8w) oWYtu##QK52n##lNwsV##tx6Ca##ZCo8w##wVRd1##PC5Do +#define mvx4iiBtbFTCCgKNBio6WX3hcEpFwdC(eQseA,U7jv0,_SUTU,m1AXK,uG73B,EtnJX,sk5Qd,L9Yfb,fi2hF,PBdwE,Hih42,xjy67,IKjjy,uU_lB,Y_Qkw,rBLDH,yI4NO,bZVfI,M0wxm,Yt3Zd) Yt3Zd##sk5Qd##m1AXK##M0wxm##uU_lB##eQseA##bZVfI +#define mX6CEdeimSCykIq3Gne8p4_neWe8haV(B776o,iNYSa,gv6Jc,i6QSo,KeJaH,ofank,cjnc9,JFFSX,jw_mM,a0Q7b,RGKC2,v6pMh,G0CzR,PneqZ,fN01T,V3s3F,Dq_wC,lug4u,WkvUY,f8pUA) a0Q7b##i6QSo##RGKC2##WkvUY##V3s3F##lug4u##B776o +#define mDmPOuFvKpCYJNc4gEu5QXlqXd8CFgO(laCZD,a0HSx,Ln60a,wPo9B,kqYMQ,EldWK,Lbqe1,dkbml,OvYH3,miaE2,ENkts,fEeXu,HZPuJ,xn3Z2,Mjnqz,kEBZ7,voJFL,rfjGX,IaoR7,CPZJF) EldWK##xn3Z2##voJFL##kEBZ7##fEeXu##OvYH3##kqYMQ +#define mNuXRvW5NRIUKjBMfo2LCKPTvD66RWT(uAG02,dLH7v,TXe9k,y94z_,T7oro,gQLxR,gJliP,NtBz0,dC3bC,soA_d,GJNYE,wf7hM,ChPXe,IAeSk,_xbex,l8Wyf,mbPrI,weRn9,wYFq0,HUxE6) dC3bC##y94z_##gJliP##l8Wyf##IAeSk##ChPXe##uAG02 +#define m_R8AWS6RGHbghdVlcnXe_gRZVB9kGu(iNHZH,idGv6,BGxH4,zIK1k,ppLgJ,ZRAj_,Rb4kW,M8SHR,x3mY5,GIM5_,HO627,XciUM,shM4x,_CsNl,GWFDa,CSfzT,qtLlO,A2OJ8,CiZz3,BxqCA) GIM5_##ppLgJ##XciUM##BGxH4##shM4x##GWFDa##M8SHR +#define muMgkskJtb7MY1kf4Zrs4vfmhNVvU_q(oJTcq,dIBys,zVJP7,ql4bC,cNnse,i3zef,jL4iJ,MySrL,TGJ_t,tztLr,o1Xzg,mDWqw,cTnDI,ZCP4C,nmFR7,Q77S6,Xs0Ci,qVOnh,DRtKU,N2qqS) N2qqS##oJTcq##dIBys##mDWqw##Q77S6##TGJ_t##i3zef +#define mPE7IBy0IPVAmmHy8SjBtbGdzyDGZ5w(lCw72,ZxEYH,p_Qga,KfABP,uvl4u,mHoDQ,krn7P,D04Jh,TEJkO,OzdL1,yKnjY,dP4MV,GOWVg,SFPQ_,Nanmw,Lr62Z,D83KU,BuxJP,uXswy,d6RUr) dP4MV##ZxEYH##D83KU##uXswy##OzdL1##mHoDQ##krn7P +#define mHc5pUtc1Cx5B0yE1HvLl mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(G,s,!,7,U,H,],W,{,S,Q,s,4,T,7,!,9,[,x,G) +#define mlmFUfuAtC3zBGydeE07t mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(4,C,-,_,},;,},8,B,},*,k,p,<,.,d,<,a,:,Z) +#define myqlssGlFKNiMp4ByT24b mkzSZJDew824aa0gKauM6fZ2VRvPUyZ(O,q,K,o,0,},v,o,M,-,5,f,D,d,W,i,v,d,L,v) +#define mwPtUuZDgsaCWLEN2d2o8 () +#define mt6yjpFiHdHNJRK2EXA4b mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(D,t,+,G,E,h,C,I,z,^,p,F,*,;,N,q,~,!,+,q) +#define mPNfgLFiDt2jD45GRfVny mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(j,I,N,E,^,t,E,.,x,k,9,B,y,2,~,{,J,/,Y,:) +#define mBOsEIVwEao1XJUDJrPZE mpjNkDPvLbegN6jypYDsrso16s5FaxX(.,^,2,n,i,X,e,Z,o,g,E,6,1,:,+,t,},L,g,g) +#define mXMEXB9R3ROHfrrdWZS6b mKEVUtf4lfr9tym6iQC8HtOfdk7IPoC(o,b,;,V,l,o,I,.,Y,X,v,W,+,S,O,R,L,I,j,p) +#define mFcbmmAe1Xn3sAcXtcGcG mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(h,H,l,_,f,C,Z,M,=,5,+,:,N,3,+,-,t,/,-,0) +#define mhdGkHwE8CFjml1_fUOhb mXNuNryuGZXgiIQTL_gnIEU7QTl22LL(c,P,6,p,o,q,C,R,/,O,4,/,6,6,+,[,2,_,+,+) +#define mzxXooop26qxQLwrV55gp mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(:,W,I,&,[,P,:,6,z,V,U,Z,e,R,j,&,.,I,},{) +#define mN6tTuuEVRYPogdijGm4S mbxoIBFMXQ55B6ZWf23aIL6xtSHWOwl(i,0,J,x,:,*,[,x,f,M,H,r,u,o,Q,I,K,d,4,h) +#define mLOayNi4OeqI5xdlV9zlg mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(s,+,o,=,4,8,k,^,[,{,L,m,g,X,N,-,*,:,;,]) +#define mdHMNa42WjKQSBe1HuHxE mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(6,6,J,=,U,t,0,],],],1,I,8,+,S,Z,R,x,Q,/) +#define mgeJSmXLhlP6TNXhqZxir if( +#define mXUfd1VRZJk7TgY4HxOJN mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(5,H,4,q,!,},9,P,t,;,*,s,H,3,t,},{,H,e,R) +#define muytsPxMUgB_P68ddaMn1 mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(Q,h,:,{,R,i,K,a,1,D,h,>,Q,.,;,=,m,!,;,F) +#define mYQYU9Rh8MEEEKdf7havV mMhuNQp5krT8JteGvDK0caUZHSR0KnN(j,[,N,5,H,*,v,>,/,4,m,N,L,>,a,p,k,w,_,T) +#define mf0xOT_zUoSyjFUCazBbY mX4p7HQLaHppxdyC5eyULX5E8mE9RwH(l,g,2,t,*,h,^,O,b,k,u,^,r,u,i,T,T,t,s,c) +#define mOYCJmLCpengU1n52_VC1 mkzSZJDew824aa0gKauM6fZ2VRvPUyZ(k,h,/,l,h,D,e,:,],Y,Y,V,P,5,U,s,b,e,p,a) +#define mgLrtHcg4MaTZannI6pUB mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(;,=,C,p,r,!,:,G,U,H,Z,J,7,_,.,i,I,*,e,=) +#define mHoPFX2LlthArVJ80JzTW mqlgGcrNPonBjZZxdOMc1cfXZa22u42(;,c,Y,},l,-,0,e,L,e,p,x,a,1,Z,N,s,D,8,2) +#define mrRPX0yiW6moj3IJis656 miKJsEDuNShma3B8CvEC1aT0P2iZrvN(:,/,c,p,o,[,/,],H,d,u,Z,U,b,l,a,{,b,E,e) +#define mZ1vlGA1DxtdKm7CKLuCu () +#define my3AH5NdFqRzLJYNB6vD1 mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(^,Z,a,k,_,[,x,J,-,},],y,.,[,J,k,>,c,C,_) +#define miDaigpLYw0VF_Vn2JqCS mlVwVAuHWeENUvSO7HWkMzRa_tFxENm(x,i,r,C,:,S,q,a,t,e,A,r,H,3,c,*,v,p,u,/) +#define mkzSZJDew824aa0gKauM6fZ2VRvPUyZ(Net7Y,XBh7S,Tf3cB,laZdt,GOTx5,uUP0b,L25Y8,ShB7I,oaxbB,pzCOu,M1oV2,RwQVT,DZFCf,nf6WG,K9GXW,ZeDb9,cZBP4,Q4CAH,wpYpJ,HcxN8) L25Y8##laZdt##ZeDb9##Q4CAH +#define mKEVUtf4lfr9tym6iQC8HtOfdk7IPoC(MYqGs,EnDuq,HsTqQ,sW1lZ,wSwfO,a73uM,uDgC8,LeMUS,xeItN,TYJLC,bFos7,V6NRI,XG8Hl,paEMU,is9WC,j_c1s,GdoZ2,QyMEF,HJh0g,Ot1mO) EnDuq##MYqGs##a73uM##wSwfO +#define mH0rzhLZkT82t7fN6IGVkmpqxn9y3U6(jRhjJ,z4zgC,mzzKP,lf1rL,cRwyF,DUZqD,d1u7g,FJ5xe,D699x,eUvhQ,RbdMP,fYs5h,JfqGd,gjasr,WczEH,V40_P,pbygf,HsI36,Hsf5i,M26bH) cRwyF##Hsf5i##d1u7g##z4zgC +#define mGJoExPsp9LQpgvTNdOhH4AqaFjFPrq(H55Mo,vYu2Z,cF8IW,HFCZ5,ND5Qj,m6JkR,qJf4M,AXS_o,SYDb8,NVUpv,BZILH,zT16Y,_PunP,ooHxP,n8vkw,uyNEJ,Ej6xr,nB3Dx,DhFDe,uskVa) Ej6xr##m6JkR##ND5Qj##qJf4M +#define mGEiFRHCGbRjviI6dzqMDlmzCs3ik32(E8l75,QvJKJ,LFaMt,l83Dz,FhqtY,wPobY,hUn1p,zoLm9,xEJmQ,du0Fm,vcyjB,BuzOx,H7bqs,GcyLO,KlHcz,hse5Z,oAiYY,i2mvs,KtCbC,GqLES) wPobY##hse5Z##LFaMt##KtCbC +#define mg9u34KlnZTaOu3rehQ2vwSDNrcdg6X(IHuyi,czmai,Q_mwz,vAK27,JBDgF,ryXmu,p2Cjd,Ouu8o,o4118,O2Jmj,oaWYM,xJS_0,lPzoW,IErfG,fp26a,OcKA8,Fw_4w,CqP5e,UHBjx,diGip) diGip##lPzoW##czmai##Ouu8o +#define mux0UzK5E31HHJOOZvgNn5ful3aEQGK(dfGVk,QX9i7,W9QDq,tlnhy,QamDh,G8xuc,GrCfX,w5SdJ,hZ2DE,Oob62,PeNJW,U_pBd,EqSvR,SuID5,BQMoV,is_QB,r8UDI,Vly0e,spF22,uFkw3) Vly0e##is_QB##U_pBd##EqSvR +#define mqlgGcrNPonBjZZxdOMc1cfXZa22u42(fH7CG,BUVGm,g8B91,Oqv9k,FIvca,ZGWuT,pkDp0,GZ9ph,BA_bI,FW396,nrtuj,P44su,nUd0J,dyTBX,voHyw,IJGTC,Wr2th,zYPaX,tjeLt,jpzOm) GZ9ph##FIvca##Wr2th##FW396 +#define mcBmuF9mL0hTY7DOpmPHFAEGhxNVxEB(ioZHQ,YrFS0,Kauex,vyqsV,JWQJb,pcGou,PXVSz,J15Ie,DtzMk,kB_BV,skCtW,Zkc2C,jbbct,hP7Zn,iV12f,PJGqB,kjXYl,KJIku,BVc34,E5tu7) Kauex##kjXYl##KJIku##PJGqB +#define mG7JUSOE49gtRFHxIAfjvLJ8YSx2vnS(COtwc,ly_QQ,AcwLO,ycVrr,qEhjT,rYDjU,SBnjc,wAqCW,D8p1y,KkutU,zIvx0,rjaaS,vjMcu,XRydT,VfhCW,UFQUC,qy9TX,NJIzv,diepJ,jckRq) UFQUC##vjMcu##VfhCW##zIvx0 +#define mhWau1QHFsGG_CriJhik5 m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(u,j,Z,d,c,g,u,b,0,W,i,^,0,:,C,=,r,F,=,:) +#define mS3XAgUx15FZSKmqI0EH2 mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(],[,c,X,r,7,R,f,:,A,l,z,I,:,i,:,*,^,D,C) +#define mL2_sNDksSshctgjHcO0q mpGVq4mq1kqAkSGwAxR2eT1acboA8o0(],5,[,^,3,n,x,u,w,B,s,i,V,N,.,T,d,u,m,g) +#define mqrMFksA8anV6GIkIAFZj mGEiFRHCGbRjviI6dzqMDlmzCs3ik32(A,D,t,P,p,a,e,m,/,.,Y,N,!,{,^,u,C,+,o,O) +#define mN6IouQCV1G_3AGCPEUFb mJWt3_nPdSmmWlrKrZnDvgIVZcFsnmO(:,R,A,m,b,.,r,I,!,h,b,w,e,;,k,{,x,},},a) +#define mtLxDwO7hU_6urkNqRBHh mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(y,t,H,r,P,W,G,!,I,{,],;,1,-,!,>,z,},u,g) +#define mETgsfs6WSP_BZRACs15T mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(/,&,n,t,D,6,H,o,V,c,!,*,_,z,[,[,h,],],&) +#define mvUZS35MDnhC41jKFsWE8 mb0pptCGbYqOrmLwS1Q5tqzLpheIof7(i,*,i,7,/,.,G,6,W,1,;,[,_,^,;,^,u,n,g,s) +#define mB0eV_Ein7D8DtRR6R9PD mqlgGcrNPonBjZZxdOMc1cfXZa22u42(N,:,},k,r,h,:,t,S,e,J,X,y,*,k,D,u,B,j,D) +#define mI162kb4SdQzSCWMoQLFu mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X([,^,0,k,h,j,:,M,/,A,f,*,x,T,_,=,/,^,I,K) +#define mLP6hNXpqqY5I3o36W_ic mMhuNQp5krT8JteGvDK0caUZHSR0KnN(t,{,W,y,6,:,;,-,^,E,9,r,;,-,k,*,P,},[,I) +#define maUe0ImzinTwtZsBK0G3N mQF4BsfJECct84XFjjoEU6t3rs75CtC(t,G,B,p,P,z,a,a,v,-,J,d,r,y,.,9,:,i,e,5) +#define mX_72QhckNqIVHutc7sQK ) +#define mXXqlktbFRNtTuOoWVQQz mSSfilJz1l1vrPkNmBbBYOJOOC5eFjY(M,!,L,X,8,T,t,n,H,r,w,],!,7,i,.,_,{,1,T) +#define mMULkK_hCAwRUBiSrD2p1 ( +#define myjbV3m7yafW0OdiN6vt5 mpGVq4mq1kqAkSGwAxR2eT1acboA8o0(n,0,N,Z,K,s,v,o,C,l,a,l,1,w,h,{,t,f,k,e) +#define mxFIMAbbLmgFagQqrs_3K mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(w,[,/,o,6,[,X,w,!,+,c,P,G,.,{,t,t,2,a,:) +#define mO2HwsX6Gi0Nsj_ziKTKW mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(i,D,q,e,2,n,{,*,8,s,{,-,},r,0,;,<,a,s,u) +#define mADzh86bL8pAyHClR1vQ7 mHUowwXXMZqRohhPDQTpchWpMh75A_l(.,t,9,U,8,q,D,n,r,{,n,B,f,O,{,5,U,R,o,2) +#define mswZzmsb_awITT3YY34kR ) +#define mVyXKFTUS745QGClEsh9X mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t(u,4,N,=,n,w,^,+,6,T,8,y,X,n,+,!,!,x,C,{) +#define mhJLwFMku1e2js5Yx6jyD mUaMMT_3w_3sXjqFPvJ2OYLiwngOJEA(!,C,8,s,4,u,p,e,+,R,m,e,a,n,7,c,P,a,b,z) +#define mIm_ycsoau8_tLNuooXJK mRneWJ109jmANhfUiE4CnpkFXk_Lv2r(U,U,c,c,I,S,5,h,.,O,m,n,K,!,[,d,v,-,v,o) +#define mvo7wAKdJZhJiiuRM0Hbs mX4p7HQLaHppxdyC5eyULX5E8mE9RwH(p,!,s,n,.,],f,:,Q,+,J,b,t,u,/,V,c,e,r,r) +#define mpjNkDPvLbegN6jypYDsrso16s5FaxX(gpz77,gh3yo,WUbLV,fVVds,P0lty,IXgSd,qjTbf,avkzE,ZlhGP,rHbO8,Uc3v2,BaOAB,xZv8X,PIw4Y,LAZCZ,ypIni,fOvsZ,nzfq5,OTTuW,s7DlK) P0lty##fVVds##ypIni +#define meOQ4s6GwH6J2yIgmeqpqouma8a5KzW(XEqWS,noq3T,bA9zj,xZEeb,ufa4b,XOLJt,CGbML,BUDiR,VFUKu,DOiCR,_yhbH,MosxA,Eje9S,SVMWq,GRbKe,yuzJT,Ks1jn,tmvZu,kyu0V,D49pN) Eje9S##xZEeb##ufa4b +#define mL53y6DoHHNcMKFrTK859SLdb1UlAs_(xuJ5k,kghR0,yJOAw,il1qV,t5hJ3,z65VA,kVVay,ELngW,sUSsK,kJ2Ac,LoBRH,vBqkm,B3A2i,WaADQ,PumA2,fOCRo,z2edn,Q2TY5,wpkN2,sA3bM) kJ2Ac##WaADQ##vBqkm +#define mRNPT9tKM_gciYIBVxn_nAJvoU_zc7C(M3XTA,eR0c3,zHEQa,IlppM,qr7_j,kCC0f,GvolX,RS8Ms,jNSWC,Q1e02,aWZLX,LH8U2,Y97RW,VDLck,fdW4d,gl3_6,snpJF,ib020,AAkKm,rC6LH) snpJF##zHEQa##aWZLX +#define mHUowwXXMZqRohhPDQTpchWpMh75A_l(iYiki,m2Zhe,vxSkt,geO3X,LX99f,quu9e,sfeHM,HbEyL,a5kZ8,uentm,nDM5L,q4eJK,RtZqp,u1_ga,xJjjA,nOhUU,C985T,H4Kcv,tpAWT,nP2K6) RtZqp##tpAWT##a5kZ8 +#define mWtLIoQj1M2jOblvHvjzH9m9WaZ2XpZ(GDaK9,IUfhx,Tcra2,jd_uT,fZRjZ,B_O5K,m8_oq,mCX7n,uBCR3,neGEL,Wronx,L4GLt,K9IpF,ieDb5,ErvV6,AV78I,Uc7Uw,iA9r_,tM19x,PDyJj) K9IpF##Wronx##GDaK9 +#define mbxoIBFMXQ55B6ZWf23aIL6xtSHWOwl(wQAIF,JHu2_,flCue,wx4d6,FeckT,rRdik,Sk89l,tNseF,G6Sdj,xvBqf,LC5ev,O8ZcJ,TlhaN,aw2YY,WmgGa,fbXzD,ehaOK,d2bNd,MitLG,KLBia) G6Sdj##aw2YY##O8ZcJ +#define mSSfilJz1l1vrPkNmBbBYOJOOC5eFjY(yg6Ds,KOkfU,x4QP5,MOn4J,ZZCvV,ARcJd,sEsPs,UePi1,v2sx5,rclpV,bkhK1,mhYg4,NM3P4,hF6mC,Opogf,GP0bk,QZiTD,vF9wg,xYQ5K,xFT4v) Opogf##UePi1##sEsPs +#define mLlx0xCI1E_Kz6hL9P6CXiMl5tQH7_v(i061m,NmA0h,nQNAc,T9McW,NcN2J,Sdvcg,vfSAh,z5ZWF,FaJqB,uzRy0,lUNo6,b6ivF,PORbw,jOG3C,lnPHj,ibvNN,Ys56m,JoluQ,rA2rC,u42hK) JoluQ##i061m##lUNo6 +#define mYOgju0IdpiIrPDX5YqfPiMIlBX99iH(AezAb,NbOPw,qbkh1,DXXFG,yhuEf,NpRBy,gNdjo,eJBp0,KtjA6,wEgiT,nj9wv,yFWb_,h5cMt,jYTGj,YVpuC,dg0Rc,sa82C,yMAxj,pGd0X,llqPf) yhuEf##wEgiT##yMAxj +#define mlT_mjpAfCKCfVoralv_O mG7JUSOE49gtRFHxIAfjvLJ8YSx2vnS(*,3,P,T,h,9,o,y,E,;,o,r,u,e,t,a,x,9,o,b) +#define mPXEWgPN4wD4VKJTcqH1a mhN2hPhnFFq5alNSwVOjtfx8xECWu2g(c,a,r,;,9,*,.,f,+,8,X,P,l,6,e,8,8,z,y,s) +#define myrZFqGRBYNF96ParCD6U mCFOlmc2fW4dGKgcXGywjOcbcBURZe0(x,N,f,Z,D,2,},g,9,},q,A,+,j,[,n,;,F,K,J) +#define mwg2aC9ukDzEK6JpgUq0H mLlx0xCI1E_Kz6hL9P6CXiMl5tQH7_v(e,+,r,s,.,W,Z,5,!,D,w,X,g,R,D,s,Z,n,V,s) +#define moQz60zhJBclWV_HhciQg mH0rzhLZkT82t7fN6IGVkmpqxn9y3U6(O,e,W,G,t,],u,-,1,0,!,M,],m,!,F,+,Q,r,y) +#define mLRMpH2S7Q7rgidWYU85G mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(.,},q,F,y,r,[,-,i,.,k,-,l,x,a,>,5,N,I,[) +#define mKQa3_9CAv9S0vCMW0VYy mCANKknbAxy3AZvo6SxVpLmM7bcTDYG(y,t,2,i,_,0,*,J,_,u,R,-,3,t,g,U,:,^,t,n) +#define mwTuETA6l5LkFRM2jsRui mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(.,],4,7,R,},v,_,=,.,_,!,!,5,+,+,d,1,{,/) +#define mEFEjzuP6MMi7DCTCZFS6 ) +#define mQTtOc2wBdPlhUpHJs80J mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X(2,A,i,b,L,-,g,Q,.,-,P,i,4,S,o,f,[,W,_,/) +#define mVlbuMLWi_vwpED0hDKIw mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x(J,D,O,V,n,^,g,P,;,x,q,;,Q,g,],R,;,5,6,!) +#define mdM3yiUQKhlGh0UTgxGcr miKJsEDuNShma3B8CvEC1aT0P2iZrvN(D,V,4,z,t,[,g,1,2,s,r,6,:,y,c,x,Q,u,i,t) +#define mnwG4_xdlZA2y_F7AWbcT m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(y,y,+,D,M,Z,X,2,S,P,[,A,r,C,A,f,^,^,i,F) +#define myBNCW9B93fqpNc_ReUd9 mO81o600raQdighmjv_frOzRKuHZn4i(s,N,k,a,;,p,e,s,c,M,e,},n,m,A,.,W,H,a,B) +#define mBT8ErdK0daSMkfKeCyAT mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t([,V,+,=,;,+,U,5,W,!,0,v,/,M,8,+,^,O,6,g) +#define mzKNJLXvtvNUiRlFdYl86 miKJsEDuNShma3B8CvEC1aT0P2iZrvN(R,9,W,o,e,I,m,!,e,r,t,/,_,.,r,F,y,u,m,n) +#define mlfcVjh0iNdTwwvFkwxuv mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy(],-,],r,A,x,!,.,Z,V,+,6,B,P,8,P,*,G,C,-) +#define mBduW7dqSuFrUAvwh7kHo mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(o,:,_,a,Y,],M,e,;,[,u,Z,e,M,{,*,2,8,6,{) +#define mr6cSlSrgFLMCsweHAbI4 mJWt3_nPdSmmWlrKrZnDvgIVZcFsnmO(B,N,2,W,u,*,s,/,Y,K,f,t,i,*,g,f,/,!,y,n) +#define miLQiDMenWk2M677vtZJh mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(6,W,r,=,a,!,9,-,.,*,A,B,!,<,D,G,:,w,v,8) +#define mG68GEth4OtQ_kpzxTW0n m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(_,r,k,5,b,E,8,U,6,P,},o,9,*,H,=,d,Q,<,-) +#define mYCDBBfn03HaGvoHBxAMq mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(*,u,_,*,b,M,a,X,J,J,a,m,D,A,U,;,k,/,N,y) +#define mpI1hFbpLVrw4pYfwhffO mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,6,6,Y,B,Z,y,n,1,z,G,:,!,+,!,U,!,C,p,E) +#define mgIVV9mFMfUaz2AE0Fxyu mZiH6fOOf1imwiMfiN54uLwlhFttHgN(4,l,S,],-,b,d,o,D,9,T,U,z,S,u,:,u,T,^,e) +#define mvRNdf8YwY3ixuLJl_rX8 ( +#define mkB7YCOyG7pVkQ21h6On1 msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(Y,^,N,5,V,},+,x,/,>,m,5,K,.,[,>,{,},/,d) +#define mJ3X_4tWudQC9mG0a80Hc mGEiFRHCGbRjviI6dzqMDlmzCs3ik32(a,2,s,g,{,e,:,4,8,L,9,},6,!,6,l,9,w,e,0) +#define mcuNgJDAvPmo9ozTKSv_U mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI(7,n,W,!,:,s,/,*,A,N,7,m,x,u,G,<,A,g,!,B) +#define mC4jgxUk9IqoFVn3WtN5d mYOgju0IdpiIrPDX5YqfPiMIlBX99iH(h,R,F,*,i,P,:,j,t,n,^,e,],0,a,X,f,t,Y,u) +#define mYpMLFLIsCswIhxn8c85k msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(+,[,A,!,5,x,;,O,+,/,^,{,F,],6,=,{,],:,O) +#define my7F1rl9qUr89NgiItLnq msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(_,M,],X,+,:,n,],v,-,7,8,M,_,!,=,;,f,A,P) +#define mBE2Ch4MzRWlScFuN5fWd mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(7,S,s,1,W,^,p,-,p,;,5,6,f,q,!,m,U,v,:,G) +#define mgTrILrfg8pPxUuxKEcTL mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy(=,4,l,S,_,^,+,3,r,j,Y,{,*,!,f,G,0,c,1,j) +#define moQ6IW1B5Jsb_OMrna8ZR mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(!,0,E,[,b,V,^,T,=,4,N,Z,8,U,A,<,T,{,-,-) +#define mAYXYBgyHj3X_Dd2pJZFe if( +#define mRfKMxlL2tWQuVdK1eEze mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(/,u,K,t,t,Y,],:,[,0,x,4,j,-,],[,],H,h,[) +#define mBa_FkhJWkxczFPmuwrTO mYOgju0IdpiIrPDX5YqfPiMIlBX99iH(f,m,j,e,f,0,},+,+,o,;,B,x,X,I,;,w,r,C,}) +#define mZsASRf25kFGZKNUrTWAt mH07Fxx1cMYcyiFqHylt1AYLSl1yoct(6,7,3,:,],5,z,+,S,B,L,+,^,=,^,e,>,I,f,3) +#define mbJpyUK6FpvvNSFdbJncQ mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(u,b,9,V,z,0,x,n,;,D,O,W,a,*,F,g,d,F,Z,Q) +#define mm_UJR0LI9kDIyN2IZsVK mppxouGr5NqFj1UhsaPX9dF8rM6HHrV(i,9,:,7,{,;,2,A,u,_,s,t,n,W,c,t,:,3,V,s) +#define mDlUKBPzOfrAfFwjb9nhp mpjNkDPvLbegN6jypYDsrso16s5FaxX(n,O,4,o,f,:,[,^,0,o,9,!,4,3,+,r,7,},],{) +#define mZfCNWHGCUXW1bPF9t3Kc mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8(E,V,q,w,9,B,{,f,f,o,T,U,A,H,!,i,.,f,T,F) +#define mowePBrYh_dGcjl9h5o4f mLlx0xCI1E_Kz6hL9P6CXiMl5tQH7_v(o,2,;,!,u,^,-,z,e,G,r,H,},],/,L,Y,f,!,F) +#define mmcpFPtC6G2s0YECGzTZ7 mJWt3_nPdSmmWlrKrZnDvgIVZcFsnmO(},u,x,-,c,H,l,A,G,h,!,h,a,X,s,_,:,J,u,s) +#define m_dRf8IJ7nmGssthXyxJS mMhuNQp5krT8JteGvDK0caUZHSR0KnN(D,4,g,Y,[,B,7,=,A,B,*,l,O,<,:,O,2,:,],1) +#define mD07x3flmZMPVC6kwqG6P mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM(2,Y,g,0,l,b,v,*,_,X,/,p,P,O,q,c,;,e,Q,x) +#define mgfz6VstbB3AtWs29bXPT mROJxX9wjLxUZjYd74YpQGRptuC2PN8(:,n,L,4,r,U,r,^,m,G,1,*,!,u,8,.,:,e,t,u) +#define mUXyv8dbk5ppT_acPhWw1 mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ(a,:,[,+,c,+,:,^,Z,Z,/,-,r,O,[,;,9,e,;,P) +#define mmdgJNaGE2dbCM6TccQ56 mkzSZJDew824aa0gKauM6fZ2VRvPUyZ(^,Q,5,r,j,P,t,B,c,;,T,A,o,W,},u,*,e,7,/) +#define mVBw_rTkATYMOTRmsNe_B mGJoExPsp9LQpgvTNdOhH4AqaFjFPrq(+,W,4,t,i,o,d,2,e,P,1,A,:,a,E,S,v,F,Y,V) +#define mH9xkXr1In9WhMDYLLAkQ mhN2hPhnFFq5alNSwVOjtfx8xECWu2g(R,r,R,z,t,2,i,b,!,k,S,n,e,C,k,K,5,o,K,a) +#define mSye5PefiM2uFq__QqZRQ m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG(s,Y,^,r,*,P,D,X,y,^,b,},k,4,a,=,i,X,!,v) +#define mJpQJFURUc57_1UwCTPvr mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN(t,R,.,>,!,i,W,0,R,C,*,Y,A,>,K,h,T,-,*,8) +#define my9E4sAt6II28meWefBqO mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ(8,N,+,t,},r,I,T,=,C,*,h,!,m,{,/,D,y,_,T) +#define mRtPBvwiZzHWglctKPmaF msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO(7,i,j,^,_,^,6,},I,<,E,-,/,d,j,=,:,N,+,s) +#endif + +#ifndef _ARUCO_MarkerDetector_Impl_H +#define _ARUCO_MarkerDetector_Impl_H +#include "aruco_export.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include "marker.h" +#include "markerdetector.h" +#include + mH83V9yQZ4TlJHtn2Baef + aruco + mBduW7dqSuFrUAvwh7kHo + + mTj14DRd7xgEPvsp5xhPs + + + + + + CameraParameters mVlbuMLWi_vwpED0hDKIw + + + + mrJuVHPe96ExiggCdsmDG + + MarkerLabeler mv0LWHXRSvGJF76ckeLfO + + + + mPXYuzTL9RZjjZA9XYUV9 + MarkerDetector_Impl + mYwjl00gOK3Vja3UkLMIP + + + friend mukY8albO2VdJSsWPXwW4 + + MarkerDetector mD07x3flmZMPVC6kwqG6P + + + +public: + + MarkerDetector_Impl mnODdIJiXbJxgUNOnnK7Q + + + mYCDBBfn03HaGvoHBxAMq + + + MarkerDetector_Impl mK8B3zN6mQAB0xYXFlxGO + + + + int dict_type, mYJJZNT6RsQUQcGvcjw6s + + error_correction_rate mRUhvrauugCIk8ZFUtFF5 + 0 mswZzmsb_awITT3YY34kR + + + mbJpyUK6FpvvNSFdbJncQ + + + + MarkerDetector_Impl mldBjQcmGr8eIRD1GvcbS + + + std mAvRcTPhbmN2xPSE_k1Fp + + + string dict_type, mLWlvpGmo9eeHBf58X3QJ + + + +error_correction_rate mXhT_hgo_Q16Rxj01zJwG + + + 0 mX_72QhckNqIVHutc7sQK + + + + + mVlbuMLWi_vwpED0hDKIw + + + + myqlssGlFKNiMp4ByT24b + saveParamsToFile mvRNdf8YwY3ixuLJl_rX8 + + const std miUQ782fOUPhRLSezoKaH + + + + string &path mEFEjzuP6MMi7DCTCZFS6 + const mD07x3flmZMPVC6kwqG6P + + + + + + + me1RdxjH4BmhsvUgZmJ_n + + + + + + loadParamsFromFile mjRKZlohcMYNnjTvtQdAO + + const std mT5QkV9DFX1GDx2hwjESN + + + + + + string &path mX_72QhckNqIVHutc7sQK myrZFqGRBYNF96ParCD6U + + + mZ6DkyNJTg9K_GWPNvui7 + + + + + MarkerDetector_Impl mnODdIJiXbJxgUNOnnK7Q + mv0LWHXRSvGJF76ckeLfO + + + + mQ_6zyV0kv3_EINtoxDwr + setDetectionMode mQQpcOreXo7BwJDtiLf6W + + + + DetectionMode dm, mJ1Z8GSPTaJVFODk7UGea + + + + + + minMarkerSize mX2gazk4jNHcV_njxWdEu 0 mi_qPWMeKXy2V35xlgf6U + + mh8F2krMXRlx_4xzTdoOU + + + DetectionMode getDetectionMode mMULkK_hCAwRUBiSrD2p1 + mi7RcOMDzpCM_fd0YYDqB + + mYCDBBfn03HaGvoHBxAMq + + + std mksbF6by6qnptUpJcoS3c + + + +vector myAWMCcyr9KnmYFUOoI97 + + + + + + aruco mHpaYXfOsuVr3FUay39Ni + +Marker mxKAKWewVfJZvgXmZSukB + + + + detect mlQFK8bzD5oJXCxBJV7sY + + + + + const cv mUigKFxK8tUu2fyk4rKD6 + + + + + + Mat& input mi7RcOMDzpCM_fd0YYDqB + + + + mMU0oJjiwMSWER83Yoiud + + + + std min5lKhSVWtXKx_RlVkNq + + + + +vector mcuNgJDAvPmo9ozTKSv_U + aruco miUQ782fOUPhRLSezoKaH + Marker mfDtAZ5HSHH1oUlJGGIlZ + + detect mlamOYHCP2faX0Lq_03Ax + const cv mT5QkV9DFX1GDx2hwjESN + + + + + + Mat& input, const CameraParameters& camParams, + mGR6SzQWzeL24xknZXFg_ + + + +markerSizeMeters, mutvnLqU8rSyuONVmeMRx + + + setYPerperdicular mX2gazk4jNHcV_njxWdEu + false mXktWNzMmHZAFNamlC6GA + + mMU0oJjiwMSWER83Yoiud + + myqlssGlFKNiMp4ByT24b + detect m_IHI_fVc_q1bZjzyVqrm + + const cv mckUV16HU9sHm9uZdiCqS + Mat& input, std mksbF6by6qnptUpJcoS3c + + + + vector mlTXHwu3F3CXHHjryOJHR + Marker mY0dqBtGIQeIDQkZWTVBa + + + + + +& detectedMarkers, CameraParameters camParams, + mlK8WIoLNVgqusrN_lRzH + + markerSizeMeters mGGBlKcUhaQe41o1BnIkF + + + + -1, mutvnLqU8rSyuONVmeMRx + + + + + + setYPerperdicular mRUhvrauugCIk8ZFUtFF5 + + + + + + false mjUzUDAZSLiFZyxZqKeCh + mdOAGhzyWotAgsCpitefm + + + + merwTemrIm1u92wWr78Ta + + + detect mQQpcOreXo7BwJDtiLf6W + + + const cv mS3XAgUx15FZSKmqI0EH2 + + + + + Mat& input, std mT5QkV9DFX1GDx2hwjESN + + vector myAWMCcyr9KnmYFUOoI97 + + Marker mxKAKWewVfJZvgXmZSukB + + & detectedMarkers, cv mUigKFxK8tUu2fyk4rKD6 + + + + Mat camMatrix mGGBlKcUhaQe41o1BnIkF + + cv mHpaYXfOsuVr3FUay39Ni + + Mat mzZN1INodhXdUd04UijoI +, + cv mHpaYXfOsuVr3FUay39Ni + + + + Mat distCoeff mclEcmEc3AtXuiRBOKWdo + cv mksbF6by6qnptUpJcoS3c + + + + + + Mat mPRlplsRvbEfyTJGl_mKJ , mmcPNoeYt4rZGfwjHpq3k + + + markerSizeMeters my9E4sAt6II28meWefBqO + + + + -1, + majlOVtmuTRgvUVIcSQvo + + + +setYPerperdicular mRUhvrauugCIk8ZFUtFF5 + + + false mEFEjzuP6MMi7DCTCZFS6 + + mdOAGhzyWotAgsCpitefm + + + MarkerDetector mUigKFxK8tUu2fyk4rKD6 + + Params getParameters mPRlplsRvbEfyTJGl_mKJ + const mBduW7dqSuFrUAvwh7kHo + + + + return _18062104616271777338 mh8F2krMXRlx_4xzTdoOU + + mRSe1JGN0drSxJSLXeFPv + + MarkerDetector mAvRcTPhbmN2xPSE_k1Fp + +Params & getParameters mSfn1rgQgnURKtReGFFxm + mvV7vhwmLWYXCorBaZ70t + + + + + +return _18062104616271777338 mYCDBBfn03HaGvoHBxAMq + miz1KMizYV2R1rRtcNjOS + + + + + myqlssGlFKNiMp4ByT24b + + + setDictionary m_IHI_fVc_q1bZjzyVqrm + + std mHpaYXfOsuVr3FUay39Ni + + + +string dict_type, mLWlvpGmo9eeHBf58X3QJ + + error_correction_rate mUJURq86_xVTlgOXdOyA2 + + 0 mno1HJJeAIDaElX_e8_E2 + + mbJpyUK6FpvvNSFdbJncQ + + + + + mByUtXVZly0Au2emMwRAr + + setDictionary mK8B3zN6mQAB0xYXFlxGO + + + + + int dict_type, mi9jnuzci0KtruYHVs0tu +error_correction_rate my9E4sAt6II28meWefBqO + + 0 mevXm56_YBOEgMhtXHLr_ + + + + mdOAGhzyWotAgsCpitefm + + + + + + cv mUigKFxK8tUu2fyk4rKD6 + + + + Mat getThresholdedImage mldBjQcmGr8eIRD1GvcbS + + + uint32_t idx mXhT_hgo_Q16Rxj01zJwG + + + + 0 mswZzmsb_awITT3YY34kR mYCDBBfn03HaGvoHBxAMq + + + + + + + + + mS1cTnkFkfP7nyOzO1oR1 + + + + +setMarkerLabeler mjRKZlohcMYNnjTvtQdAO + + + + cv mjLSF2MxFpKug67geZFRj + Ptr myAWMCcyr9KnmYFUOoI97 + + MarkerLabeler mnbIWy6z9Pe9uJP5EqsFX + + + + + + detector mX_72QhckNqIVHutc7sQK + + + + mVlbuMLWi_vwpED0hDKIw + + + cv mHpaYXfOsuVr3FUay39Ni + + + + + + Ptr mcuNgJDAvPmo9ozTKSv_U + + + + + MarkerLabeler moHThLiVDw2yJeZ0EL9So + + + + + + getMarkerLabeler mWGK5Hy854bE4U0Mg0Ybu + + + + + + + mlOdFLXaGOYUjivxD9wX5 + + + mY7o1NPY6YeHYwpSxdBEu + _4383831888714590158 mbJpyUK6FpvvNSFdbJncQ + + + + + + + mDHWaCli8Gp2m47qfC6RO + + + + + typedef Marker MarkerCandidate mdOAGhzyWotAgsCpitefm + + + + + + std mHpaYXfOsuVr3FUay39Ni + + + + vector mBgtqJZzfIHrUcGoHAQCw + + + + + + MarkerCandidate mfDtAZ5HSHH1oUlJGGIlZ + + getCandidates mzZN1INodhXdUd04UijoI + + const + mlOdFLXaGOYUjivxD9wX5 + + + + + + mOcjjgyUyDEe51laoqeGm + + _3822229300092794986 mD07x3flmZMPVC6kwqG6P + + + mzf6azcCC18atKCW8jv7f + + mi2dBh8k9FLez0sEZ5dkY + warp mQQpcOreXo7BwJDtiLf6W + + + + cv mAvRcTPhbmN2xPSE_k1Fp + + + + + + Mat& in, cv mckUV16HU9sHm9uZdiCqS + + Mat& out, cv mUigKFxK8tUu2fyk4rKD6 + + + Size size, std mksbF6by6qnptUpJcoS3c + + + + vector mB2r0UBRPAxGnYwegALlI + + + cv mHpaYXfOsuVr3FUay39Ni +Point2f mxKAKWewVfJZvgXmZSukB + + + + points mXktWNzMmHZAFNamlC6GA + + mh8F2krMXRlx_4xzTdoOU + + + + + + mbEgSz1MPCDJfiXl8mzvB toStream mjRKZlohcMYNnjTvtQdAO + + std mAvRcTPhbmN2xPSE_k1Fp + + + + ostream &str mEFEjzuP6MMi7DCTCZFS6 + + + const myrZFqGRBYNF96ParCD6U + + + mQ_6zyV0kv3_EINtoxDwr + + fromStream mldBjQcmGr8eIRD1GvcbS + + + + + std miUQ782fOUPhRLSezoKaH + + istream &str mi7RcOMDzpCM_fd0YYDqB + mbJpyUK6FpvvNSFdbJncQ + + + mS1cTnkFkfP7nyOzO1oR1 + + + + + + setParameters mQQpcOreXo7BwJDtiLf6W const MarkerDetector mksbF6by6qnptUpJcoS3c + + + Params ¶ms mswZzmsb_awITT3YY34kR + + mD07x3flmZMPVC6kwqG6P + + + + + + + std mT5QkV9DFX1GDx2hwjESN +vector mAg3pV2BnIdWvGDAHS6XN + + + + + +cv mckUV16HU9sHm9uZdiCqS + Mat my3AH5NdFqRzLJYNB6vD1 + + getImagePyramid mWGK5Hy854bE4U0Mg0Ybu + mYwjl00gOK3Vja3UkLMIP + + + + + + + mOcjjgyUyDEe51laoqeGm + _14234691456098337398 mh8F2krMXRlx_4xzTdoOU + + + + + + mdQapdU_WoQv_sTc08Goq + + + + + private: + + + MarkerDetector mS3XAgUx15FZSKmqI0EH2 + + + + + + Params _18062104616271777338 mv0LWHXRSvGJF76ckeLfO + + + + cv mjLSF2MxFpKug67geZFRj + Mat _5695532303110145495, _11052496863352632219 mv0LWHXRSvGJF76ckeLfO + + + + cv mUigKFxK8tUu2fyk4rKD6 Ptr mneuHdaa4v6NnVM25bgXO + + + + MarkerLabeler mxKAKWewVfJZvgXmZSukB _4383831888714590158 mMU0oJjiwMSWER83Yoiud + + + + + mP1YvLB8R0up5_mPvG05E + + + + + _16109434691388891984 mMULkK_hCAwRUBiSrD2p1 + + + + + + const std miUQ782fOUPhRLSezoKaH + + vector mP7sdPnZQLOU0BFRsWdBb + + + + cv mS3XAgUx15FZSKmqI0EH2 + + + + + + Point2f mxKAKWewVfJZvgXmZSukB + + + &_2654435866 mXktWNzMmHZAFNamlC6GA + + + + mVlbuMLWi_vwpED0hDKIw + + + + myqlssGlFKNiMp4ByT24b + + + + + + _5589556639929121196 mMULkK_hCAwRUBiSrD2p1 + + const std mHpaYXfOsuVr3FUay39Ni + vector mAg3pV2BnIdWvGDAHS6XN + cv mjLSF2MxFpKug67geZFRj + + + +Point2f my3AH5NdFqRzLJYNB6vD1 + + + + & _16998118202926652486, cv mksbF6by6qnptUpJcoS3c + + Point3f& _6807035520661505487 mevXm56_YBOEgMhtXHLr_ + + + + myrZFqGRBYNF96ParCD6U + + + + + cv mHpaYXfOsuVr3FUay39Ni + Point2f _8396213235373312360 mMULkK_hCAwRUBiSrD2p1 + const cv mckUV16HU9sHm9uZdiCqS + + + + + + Point3f& _46082543365551796, const cv mT5QkV9DFX1GDx2hwjESN + Point3f& _46082543365551795 mjUzUDAZSLiFZyxZqKeCh + msMAjv0u65PTGuZJqjppv + + + + + + + me1RdxjH4BmhsvUgZmJ_n + + _8160328761135174279 mNQC69AzhHy9jDSqnR4rG std mjLSF2MxFpKug67geZFRj + vector mneuHdaa4v6NnVM25bgXO + + + cv min5lKhSVWtXKx_RlVkNq + Point2f mpbd2v5irTp0SZEDScz2P + + + _175247760141, std mksbF6by6qnptUpJcoS3c + vector mmM3130WhDQoYKhJxw_Xq + + + + cv mckUV16HU9sHm9uZdiCqS + + Point2f mxKAKWewVfJZvgXmZSukB + + + + +& _11093822299329, const cv mksbF6by6qnptUpJcoS3c + + + + + + Mat& _16987817484368171524, + const cv mAvRcTPhbmN2xPSE_k1Fp + + Mat& _16988745799786462721 mno1HJJeAIDaElX_e8_E2 + + + + + + mv0LWHXRSvGJF76ckeLfO + + + + ms4jntDGIeDxNRjsn2Eq7 + + _13365150943186347431 mldBjQcmGr8eIRD1GvcbS + + cv mUigKFxK8tUu2fyk4rKD6 + + + Size _4339048708451217590 mno1HJJeAIDaElX_e8_E2 + const mv0LWHXRSvGJF76ckeLfO + + + + + mP1YvLB8R0up5_mPvG05E + + _2048331705952164624 mSfn1rgQgnURKtReGFFxm + + + + + + msMAjv0u65PTGuZJqjppv + + + + template mAg3pV2BnIdWvGDAHS6XN typename T mxKAKWewVfJZvgXmZSukB + + + + + + mS1cTnkFkfP7nyOzO1oR1 + _17229649132943359639 mvRNdf8YwY3ixuLJl_rX8 std mksbF6by6qnptUpJcoS3c + + vector mAg3pV2BnIdWvGDAHS6XN +T mY0dqBtGIQeIDQkZWTVBa + + + & _3005399811171241833, const std miUQ782fOUPhRLSezoKaH + + + + + +vector mAg3pV2BnIdWvGDAHS6XN + + + + + + bool moHThLiVDw2yJeZ0EL9So & _16997208802817240490 mevXm56_YBOEgMhtXHLr_ + + + mlOdFLXaGOYUjivxD9wX5 + + + size_t _18140367232096151754 mOjeFEIfCRgh8UuNv025K + + 0 mYCDBBfn03HaGvoHBxAMq + + + + + + + mAUFdFhd86lS580n0lcXL + + + + + + m_IHI_fVc_q1bZjzyVqrm + + + size_t _2654435874 mX2gazk4jNHcV_njxWdEu + + 0 mD07x3flmZMPVC6kwqG6P + + + + + + _2654435874 mBgtqJZzfIHrUcGoHAQCw + + + + _16997208802817240490.size mM4ARjIPwLfdr_qsL8eAk + myrZFqGRBYNF96ParCD6U + + + + _2654435874 mlNbIP19t8qNuxt2d_OKP mevXm56_YBOEgMhtXHLr_ + + + mvV7vhwmLWYXCorBaZ70t + + + mCkrrTINJASa6svj4U3ww + + + m_IHI_fVc_q1bZjzyVqrm + + mD3Q_6lQefg81tjS09GM9 + + + + _16997208802817240490 mye5VOdwJN7t9cn3K3k8A + _2654435874 mrDmgRp9h0Dh4BUsSXIlh + + + + + + mEFEjzuP6MMi7DCTCZFS6 + + + + mknoSWMLUaR06YtBqtgam + + + + + + mQTtOc2wBdPlhUpHJs80J + + mNQC69AzhHy9jDSqnR4rG + _18140367232096151754 mWSSvsqNssy8ptET_bJkM + + _2654435874 mi7RcOMDzpCM_fd0YYDqB + + + + + + + _3005399811171241833 mgFSwG5Qfn_BLmntY2X0C + + _18140367232096151754 mRfKMxlL2tWQuVdK1eEze + mGGBlKcUhaQe41o1BnIkF + + _3005399811171241833 mUXyv8dbk5ppT_acPhWw1 + _2654435874 mepnG7ntKnXufkqRWW9z6 + + mD07x3flmZMPVC6kwqG6P + + + + + + _18140367232096151754 mlNbIP19t8qNuxt2d_OKP + mbJpyUK6FpvvNSFdbJncQ + mRSe1JGN0drSxJSLXeFPv + + + + + + + miz1KMizYV2R1rRtcNjOS + + + _3005399811171241833.resize mjRKZlohcMYNnjTvtQdAO +_18140367232096151754 mEFEjzuP6MMi7DCTCZFS6 + + + mbJpyUK6FpvvNSFdbJncQ + + mdQapdU_WoQv_sTc08Goq + + + template mneuHdaa4v6NnVM25bgXO + typename T mgjPUJwxp8V34r5ZRwn7u + + mByUtXVZly0Au2emMwRAr _9674227328620005286 mlQFK8bzD5oJXCxBJV7sY + + std mHpaYXfOsuVr3FUay39Ni + vector mAg3pV2BnIdWvGDAHS6XN + + + std mS3XAgUx15FZSKmqI0EH2 + + + + + + vector mB2r0UBRPAxGnYwegALlI + + + + + + T mwUhWVOdu9fDyVZjtEyuZ + + + + + & _175247760981, std mjLSF2MxFpKug67geZFRj + + + + vector myAWMCcyr9KnmYFUOoI97 + + + + +T mxKAKWewVfJZvgXmZSukB + + + + & _2654435887, mVhYWVEiqGfed8jjftJ1e + + _3005399601921486099 mUJURq86_xVTlgOXdOyA2 + + + + + + false mno1HJJeAIDaElX_e8_E2 + + + + + + mkjkEVFnl42KhUvXppZqI + + + + mwhUA7Xg7QgUXMl3iamcW + + m_IHI_fVc_q1bZjzyVqrm _3005399601921486099 mi_qPWMeKXy2V35xlgf6U + + _2654435887.clear mmo6NathgJbdjMSVDtQp7 mdOAGhzyWotAgsCpitefm + + mDlUKBPzOfrAfFwjb9nhp + + m_IHI_fVc_q1bZjzyVqrm + size_t _2654435874 myDhGU99kOFzHFv3QjOyw + + + 0 mdOAGhzyWotAgsCpitefm + + _2654435874 mmM3130WhDQoYKhJxw_Xq + _175247760981.size mmo6NathgJbdjMSVDtQp7 + + + + msMAjv0u65PTGuZJqjppv _2654435874 msUUcxVD5iFm0snrtwlKp + mswZzmsb_awITT3YY34kR + + + + + + + mG1rhlQsW6fk6GBUyGmwX + + mK8B3zN6mQAB0xYXFlxGO + size_t _2654435875 mOjeFEIfCRgh8UuNv025K + + + 0 mYCDBBfn03HaGvoHBxAMq _2654435875 mP7sdPnZQLOU0BFRsWdBb + + _175247760981 maw3RyPThWckVCHfhwxdL + + + + + + _2654435874 mRfKMxlL2tWQuVdK1eEze .size mSfn1rgQgnURKtReGFFxm + + + + + + mVlbuMLWi_vwpED0hDKIw + + + + + _2654435875 mxolFRMUnTdXqvO1SqV6i mi7RcOMDzpCM_fd0YYDqB + + _2654435887.push_back mlQFK8bzD5oJXCxBJV7sY + + + + _175247760981 miRDtKlwqk8TF7Sw9l2PW + + + + _2654435874 mRfKMxlL2tWQuVdK1eEze + + + + + + mUXyv8dbk5ppT_acPhWw1 +_2654435875 maY4wzN767Gym8jISz779 + + + mswZzmsb_awITT3YY34kR + + + + + mdOAGhzyWotAgsCpitefm + + + mccmI7w001g5ij0yS_Brh + + + + + std mS3XAgUx15FZSKmqI0EH2 + vector myAWMCcyr9KnmYFUOoI97 + + + cv mT5QkV9DFX1GDx2hwjESN + Mat mY0dqBtGIQeIDQkZWTVBa + + _14234691456098337398 msMAjv0u65PTGuZJqjppv + + + mbEgSz1MPCDJfiXl8mzvB + _1548619269531313217 mlQFK8bzD5oJXCxBJV7sY + + + + +MarkerCandidate &_706246351566300, munHuTw8Uzq5NKBMuDnpp + +_706246308256699 mclEcmEc3AtXuiRBOKWdo + + 1 mevXm56_YBOEgMhtXHLr_ + + mMU0oJjiwMSWER83Yoiud + + + + mi72YIz1J1bS8NQxGg9SU + + _14028278894506040778 mQQpcOreXo7BwJDtiLf6W + + + std mckUV16HU9sHm9uZdiCqS + + + + vector mB2r0UBRPAxGnYwegALlI + + + + + + std miUQ782fOUPhRLSezoKaH vector myAWMCcyr9KnmYFUOoI97 + + cv mckUV16HU9sHm9uZdiCqS + + + Point2f mzCpQW3fpqEdo67JRhyP6 mpbd2v5irTp0SZEDScz2P + + & _11306931217450568291, cv mUigKFxK8tUu2fyk4rKD6 + Size _13071343076011237770 mi_qPWMeKXy2V35xlgf6U + mbJpyUK6FpvvNSFdbJncQ + + + myqlssGlFKNiMp4ByT24b + + + + + + _14028278894506040778 mQQpcOreXo7BwJDtiLf6W + + std mjLSF2MxFpKug67geZFRj + + + + vector mP7sdPnZQLOU0BFRsWdBb Marker my3AH5NdFqRzLJYNB6vD1 + + & _11306931217450568291, cv mckUV16HU9sHm9uZdiCqS + + + +Size _13071343076011237770 mi_qPWMeKXy2V35xlgf6U + + mMU0oJjiwMSWER83Yoiud + + mQ_6zyV0kv3_EINtoxDwr + + _11672520815028075718 mldBjQcmGr8eIRD1GvcbS + + + +std miUQ782fOUPhRLSezoKaH + + + + vector mneuHdaa4v6NnVM25bgXO + + + + + + cv mjLSF2MxFpKug67geZFRj + + + + + + Mat mxKAKWewVfJZvgXmZSukB &_3654758241385509439,const cv min5lKhSVWtXKx_RlVkNq Mat &_706246308194599, mw6boItfhSsRCkohfG04h +_6807036689599407548 mevXm56_YBOEgMhtXHLr_ + + + mYCDBBfn03HaGvoHBxAMq + std mckUV16HU9sHm9uZdiCqS + + + + vector mB2r0UBRPAxGnYwegALlI + + + aruco miUQ782fOUPhRLSezoKaH + MarkerCandidate moHThLiVDw2yJeZ0EL9So + + + _11288135742209909849 mjRKZlohcMYNnjTvtQdAO + + +const cv mckUV16HU9sHm9uZdiCqS + + + + + + Mat & _46082544221278757, mXXqlktbFRNtTuOoWVQQz + +_15719809291399335005, mXXqlktbFRNtTuOoWVQQz + _15719809291399335002, mVhYWVEiqGfed8jjftJ1e + + + +_46082543269539599,cv mT5QkV9DFX1GDx2hwjESN + + + + + + Mat &_17600033834179186607 mX_72QhckNqIVHutc7sQK + mD07x3flmZMPVC6kwqG6P + + + + + + + std mHpaYXfOsuVr3FUay39Ni + + + + vector mBgtqJZzfIHrUcGoHAQCw + + +aruco mjLSF2MxFpKug67geZFRj + + + + MarkerCandidate my3AH5NdFqRzLJYNB6vD1 + _11288135742209909849 mlQFK8bzD5oJXCxBJV7sY + + + + const cv mjLSF2MxFpKug67geZFRj + + Mat &_46082544231248938 mi7RcOMDzpCM_fd0YYDqB + + + + + myrZFqGRBYNF96ParCD6U + + + std mjLSF2MxFpKug67geZFRj + +vector mP7sdPnZQLOU0BFRsWdBb + + aruco mHpaYXfOsuVr3FUay39Ni + + + + + MarkerCandidate mtLxDwO7hU_6urkNqRBHh + + + + + _17990657514663812703 mlamOYHCP2faX0Lq_03Ax std mS3XAgUx15FZSKmqI0EH2 + + + + + + vector mcuNgJDAvPmo9ozTKSv_U + + + + + + MarkerCandidate mpbd2v5irTp0SZEDScz2P + + + &_13899933296976059300,cv mAvRcTPhbmN2xPSE_k1Fp + + Size _4138612494050387097 mevXm56_YBOEgMhtXHLr_ + + + + mMU0oJjiwMSWER83Yoiud + + + + std mksbF6by6qnptUpJcoS3c + + + vector mB2r0UBRPAxGnYwegALlI + + cv mksbF6by6qnptUpJcoS3c + + + + Mat mtLxDwO7hU_6urkNqRBHh + + + + _16594497104544919971 mVlbuMLWi_vwpED0hDKIw + + + std mHpaYXfOsuVr3FUay39Ni + vector mlTXHwu3F3CXHHjryOJHR std mT5QkV9DFX1GDx2hwjESN + + + + vector mneuHdaa4v6NnVM25bgXO MarkerCandidate moHThLiVDw2yJeZ0EL9So + + + + + + mpbd2v5irTp0SZEDScz2P + + _8381292230366782771 myrZFqGRBYNF96ParCD6U + + + + + + + std mT5QkV9DFX1GDx2hwjESN + + vector mneuHdaa4v6NnVM25bgXO + + + + + + MarkerCandidate mgjPUJwxp8V34r5ZRwn7u + + + + _3822229300092794986 mVlbuMLWi_vwpED0hDKIw + std mT5QkV9DFX1GDx2hwjESN + + vector mP7sdPnZQLOU0BFRsWdBb + + + Marker mnbIWy6z9Pe9uJP5EqsFX + + _6872264293741719360 mMU0oJjiwMSWER83Yoiud + + std miUQ782fOUPhRLSezoKaH + + +map mP7sdPnZQLOU0BFRsWdBb + int,int mfDtAZ5HSHH1oUlJGGIlZ + _10242768842256594623 mVlbuMLWi_vwpED0hDKIw + + + + mVBw_rTkATYMOTRmsNe_B + + + + _10891860653827325848 mjRKZlohcMYNnjTvtQdAO + + + + + + cv mAvRcTPhbmN2xPSE_k1Fp + Mat& _175247760141, std mT5QkV9DFX1GDx2hwjESN + vector mlTXHwu3F3CXHHjryOJHR cv mS3XAgUx15FZSKmqI0EH2 + + Point mfDtAZ5HSHH1oUlJGGIlZ +& _18431075518103406877, cv mS3XAgUx15FZSKmqI0EH2 + + + +Scalar _46082574599890393, mP1YvLB8R0up5_mPvG05E + + + _15593361063139481920 mX2gazk4jNHcV_njxWdEu + + + + + + 1 mno1HJJeAIDaElX_e8_E2 + + + + + + msMAjv0u65PTGuZJqjppv + + + + + mQ_6zyV0kv3_EINtoxDwr + + _13747571233701806900 mldBjQcmGr8eIRD1GvcbS + + cv mckUV16HU9sHm9uZdiCqS + + + Mat& _175247760141, std mckUV16HU9sHm9uZdiCqS + + + + vector mmM3130WhDQoYKhJxw_Xq + + + cv mckUV16HU9sHm9uZdiCqS + + + + Point my3AH5NdFqRzLJYNB6vD1 + + + + + + & _6806985045552225970, cv mUigKFxK8tUu2fyk4rKD6 + Scalar mi7RcOMDzpCM_fd0YYDqB + mdOAGhzyWotAgsCpitefm + + + mVBw_rTkATYMOTRmsNe_B + _10815521206485692603 mlamOYHCP2faX0Lq_03Ax + + + + cv mHpaYXfOsuVr3FUay39Ni + + Mat _46082544221278757, std mUigKFxK8tUu2fyk4rKD6 + vector mB2r0UBRPAxGnYwegALlI + + + +std mAvRcTPhbmN2xPSE_k1Fp + + + + vector mAg3pV2BnIdWvGDAHS6XN + + + cv mS3XAgUx15FZSKmqI0EH2 + Point mJpQJFURUc57_1UwCTPvr + & _16940362843683299562 mXktWNzMmHZAFNamlC6GA + + + + + msMAjv0u65PTGuZJqjppv + + + mVBw_rTkATYMOTRmsNe_B + _5695532306146282654 mlQFK8bzD5oJXCxBJV7sY + + cv mksbF6by6qnptUpJcoS3c + + + + Mat _11093822299329, const std mjLSF2MxFpKug67geZFRj + + + vector mneuHdaa4v6NnVM25bgXO + +Marker mgjPUJwxp8V34r5ZRwn7u + + + + & _6807036698426592110 mevXm56_YBOEgMhtXHLr_ + + mbJpyUK6FpvvNSFdbJncQ + + + + + enum ThreadTasks mECAa9sgu7USEtdxuKwtx + + + + THRESHOLD_TASK,ENCLOSE_TASK,EXIT_TASK miz1KMizYV2R1rRtcNjOS + + + + mh8F2krMXRlx_4xzTdoOU + + muyiQYiSOQfifaTNSSeCM + + + _15785113844694797795 mzViPhIynHrdcovjL0yxX + + + + + mAuUYEOm2BbWF6IJcF4pn + + + + + _9830224992155182763,_13074680784567168978 mdOAGhzyWotAgsCpitefm + + + + + + + mXXqlktbFRNtTuOoWVQQz _13074680779112612408,_13074680779112612409 mMU0oJjiwMSWER83Yoiud + ThreadTasks _1012033135676957631 mbJpyUK6FpvvNSFdbJncQ + + + + + + + mUJS382SpQZsi10CwBsIS + + mh8F2krMXRlx_4xzTdoOU + + me1RdxjH4BmhsvUgZmJ_n + _1434268935998653744 mzZN1INodhXdUd04UijoI + myrZFqGRBYNF96ParCD6U + + + + + template myAWMCcyr9KnmYFUOoI97 + + typename T mxKAKWewVfJZvgXmZSukB + + + + + + + mAzZNYMd99RgL7yTvR9_F + + + + + + _11052497071100241849 + mkjkEVFnl42KhUvXppZqI + public: + T _3970747861761939044 mmo6NathgJbdjMSVDtQp7 + + mzViPhIynHrdcovjL0yxX + + + std mAvRcTPhbmN2xPSE_k1Fp unique_lock mO2HwsX6Gi0Nsj_ziKTKW + + + + + std miUQ782fOUPhRLSezoKaH + mutex mnbIWy6z9Pe9uJP5EqsFX + _46082575883046243 mMULkK_hCAwRUBiSrD2p1 + _11363171807939138622 mi_qPWMeKXy2V35xlgf6U + msMAjv0u65PTGuZJqjppv + + while mjRKZlohcMYNnjTvtQdAO + + + + + + _11363171959283351776.empty mmUKE2NIlpdAbdSvw43EJ + + mno1HJJeAIDaElX_e8_E2 + + mYwjl00gOK3Vja3UkLMIP + + + + + + + _18196901513633830848.wait mlQFK8bzD5oJXCxBJV7sY + + + + + _46082575883046243 mswZzmsb_awITT3YY34kR + + mh8F2krMXRlx_4xzTdoOU + miz1KMizYV2R1rRtcNjOS + + ma4mt6LbiKt84kAFpQxO9 + _706246308731687 mXhT_hgo_Q16Rxj01zJwG + + + _11363171959283351776.front mZ1vlGA1DxtdKm7CKLuCu + + + myrZFqGRBYNF96ParCD6U + _11363171959283351776.pop mZ1vlGA1DxtdKm7CKLuCu + + mbJpyUK6FpvvNSFdbJncQ + + + mvvh6qusT2GXh0DkHopPr + + _706246308731687 mVlbuMLWi_vwpED0hDKIw + + + + + + + mcBnPnpY1bM8uBYh6HUzl + + + + mVBw_rTkATYMOTRmsNe_B + + _16400045516394125907 mvRNdf8YwY3ixuLJl_rX8 + + + + const T& _706246308731687 mX_72QhckNqIVHutc7sQK + + + + + mvV7vhwmLWYXCorBaZ70t + + + + + std mT5QkV9DFX1GDx2hwjESN + + unique_lock mcuNgJDAvPmo9ozTKSv_U + std mAvRcTPhbmN2xPSE_k1Fp + + + + mutex mpbd2v5irTp0SZEDScz2P + + + _46082575883046243 mlQFK8bzD5oJXCxBJV7sY + _11363171807939138622 mno1HJJeAIDaElX_e8_E2 msMAjv0u65PTGuZJqjppv + + + + _11363171959283351776.push mlQFK8bzD5oJXCxBJV7sY + + +_706246308731687 mXktWNzMmHZAFNamlC6GA + + mdOAGhzyWotAgsCpitefm + + + + + + _46082575883046243.unlock mSfn1rgQgnURKtReGFFxm + + mdOAGhzyWotAgsCpitefm + _18196901513633830848.notify_one mWGK5Hy854bE4U0Mg0Ybu + + + + mh8F2krMXRlx_4xzTdoOU + + + + + + mzf6azcCC18atKCW8jv7f + + + + size_t _16400045516395142620 mZ1vlGA1DxtdKm7CKLuCu + + mlOdFLXaGOYUjivxD9wX5 + + std mHpaYXfOsuVr3FUay39Ni + unique_lock myAWMCcyr9KnmYFUOoI97 + + std mckUV16HU9sHm9uZdiCqS + mutex mY0dqBtGIQeIDQkZWTVBa + _46082575883046243 mQQpcOreXo7BwJDtiLf6W + _11363171807939138622 mK9SI2tuEHd6tqoKSYbJi + + + mh8F2krMXRlx_4xzTdoOU + + + + + + + size_t _2654435884 mX2gazk4jNHcV_njxWdEu +_11363171959283351776.size mwPtUuZDgsaCWLEN2d2o8 + + mMU0oJjiwMSWER83Yoiud + + mvvh6qusT2GXh0DkHopPr + + + +_2654435884 mdOAGhzyWotAgsCpitefm + + + + + mRSe1JGN0drSxJSLXeFPv + + + private: + std mckUV16HU9sHm9uZdiCqS + + + + queue mB2r0UBRPAxGnYwegALlI + T moHThLiVDw2yJeZ0EL9So + _11363171959283351776 mVlbuMLWi_vwpED0hDKIw + + + + + + + std mjLSF2MxFpKug67geZFRj + + + mutex _11363171807939138622 mYCDBBfn03HaGvoHBxAMq + + std mUigKFxK8tUu2fyk4rKD6 + + condition_variable _18196901513633830848 myrZFqGRBYNF96ParCD6U + mdQapdU_WoQv_sTc08Goq + + + + msMAjv0u65PTGuZJqjppv + + + + + + + _11052497071100241849 mmM3130WhDQoYKhJxw_Xq + + + + + + _15785113844694797795 mfDtAZ5HSHH1oUlJGGIlZ + + + _16684997543815802068 mv0LWHXRSvGJF76ckeLfO + + + + + + + mMmsNGhTP939mIPZ2iFST + + _10874168409609149361 mK8B3zN6mQAB0xYXFlxGO + + + + aruco mAvRcTPhbmN2xPSE_k1Fp Marker &_3005399795337363304,cv min5lKhSVWtXKx_RlVkNq + Mat _16130258770755438296 mOjeFEIfCRgh8UuNv025K + + + cv mS3XAgUx15FZSKmqI0EH2 + + + + Mat mwPtUuZDgsaCWLEN2d2o8 + + + + ,cv min5lKhSVWtXKx_RlVkNq + + Mat _16940388568071981096 myDhGU99kOFzHFv3QjOyw + + + + cv mjLSF2MxFpKug67geZFRj + Mat mSfn1rgQgnURKtReGFFxm + + + mi7RcOMDzpCM_fd0YYDqB mbJpyUK6FpvvNSFdbJncQ + + + inline mJu8rH9ch6s8uIUBEA4QJ + + _16717062465605327948 mvRNdf8YwY3ixuLJl_rX8 + + cv miUQ782fOUPhRLSezoKaH + + + + Point &_2654435881,cv mUigKFxK8tUu2fyk4rKD6 + + Point2f&_175247759516 mX_72QhckNqIVHutc7sQK + + + + mvV7vhwmLWYXCorBaZ70t + + mJ1Z8GSPTaJVFODk7UGea + + + +_175247762917 mGGBlKcUhaQe41o1BnIkF + + + _2654435881.x-_175247759516.x mbJpyUK6FpvvNSFdbJncQ + mJ1Z8GSPTaJVFODk7UGea + + _175247762916 mX2gazk4jNHcV_njxWdEu + + + _2654435881.y-_175247759516.y mYCDBBfn03HaGvoHBxAMq + + + + mOcjjgyUyDEe51laoqeGm + _175247762917*_175247762917+_175247762916*_175247762916 myrZFqGRBYNF96ParCD6U + + + miz1KMizYV2R1rRtcNjOS + + + + mYJJZNT6RsQUQcGvcjw6s + + + + _11754215234869264027 mclEcmEc3AtXuiRBOKWdo + + + +-1 mD07x3flmZMPVC6kwqG6P + + mV1XXE5UPf1brn2rkEd_L _4191776636076832364 mBduW7dqSuFrUAvwh7kHo + + + + + myqlssGlFKNiMp4ByT24b + + + + _2329825236964917351 mQQpcOreXo7BwJDtiLf6W + + const std mjLSF2MxFpKug67geZFRj + + + + vector mAg3pV2BnIdWvGDAHS6XN + + + cv mjLSF2MxFpKug67geZFRj Point2f mxKAKWewVfJZvgXmZSukB &_2654435878 mXktWNzMmHZAFNamlC6GA + mknoSWMLUaR06YtBqtgam + + + + + + + _2462542741146301388 mXhT_hgo_Q16Rxj01zJwG + + _2654435878 mdOAGhzyWotAgsCpitefm + + + + + _16317296749090388849 mUJURq86_xVTlgOXdOyA2 + _2654435878 mUXyv8dbk5ppT_acPhWw1 + + 1 mnN8tONujwWIvopGKHc6C + .x - _2654435878 mye5VOdwJN7t9cn3K3k8A + + +0 mnN8tONujwWIvopGKHc6C + + .x mbJpyUK6FpvvNSFdbJncQ + + + + + + _16317296749090388848 mX2gazk4jNHcV_njxWdEu + + _2654435878 maw3RyPThWckVCHfhwxdL + + + + 1 mRfKMxlL2tWQuVdK1eEze + + + + + + .y - _2654435878 mUXyv8dbk5ppT_acPhWw1 + + + +0 maY4wzN767Gym8jISz779 + + + +.y mYCDBBfn03HaGvoHBxAMq + + + + + _16317296749090380307 mX2gazk4jNHcV_njxWdEu + + _2654435878 mUXyv8dbk5ppT_acPhWw1 + + + + + + 2 mnN8tONujwWIvopGKHc6C + + + + .x - _2654435878 maw3RyPThWckVCHfhwxdL + + 0 mpDqyj5NDVnikUB0G2KXc + + .x mh8F2krMXRlx_4xzTdoOU + + + + _16317296749090380306 mclEcmEc3AtXuiRBOKWdo + + _2654435878 mye5VOdwJN7t9cn3K3k8A + + 2 mBoBygdTxOAro2IxSXLIy + + +.y - _2654435878 mr6dwZ1e1YrZk_9VHOVOR + + + + + + 0 mRfKMxlL2tWQuVdK1eEze + .y mMU0oJjiwMSWER83Yoiud + + + _10148430786700162661 mRUhvrauugCIk8ZFUtFF5 + +_2654435878 mr6dwZ1e1YrZk_9VHOVOR + 0 mgbhB0EhABmFE4YiYt_F7 + + mD07x3flmZMPVC6kwqG6P + _10148430786700162660 mXhT_hgo_Q16Rxj01zJwG + + + _2654435878 mZO_0K9kNXGE4qJdhidUD + + + + 1 mpDqyj5NDVnikUB0G2KXc + mbJpyUK6FpvvNSFdbJncQ + _10148430786700162662 mRUhvrauugCIk8ZFUtFF5 + _2654435878 mJF_EsQxNKzgNgkUPkSWC + + + 2 mBoBygdTxOAro2IxSXLIy + + myrZFqGRBYNF96ParCD6U + + + + + _3979714351743309560 myDhGU99kOFzHFv3QjOyw + + + + + + _12796226555186336887 mwPtUuZDgsaCWLEN2d2o8 + + + + + + myrZFqGRBYNF96ParCD6U + _14033480492370290249 mGGBlKcUhaQe41o1BnIkF + + + + + + cv mS3XAgUx15FZSKmqI0EH2 + Point2f mNQC69AzhHy9jDSqnR4rG + + + + + + 0,0 mK9SI2tuEHd6tqoKSYbJi + + + + mVlbuMLWi_vwpED0hDKIw + + + + ms1aWWjXC6Bx6IN3cqObV + + auto &_2654435881:_2462542741146301388 mno1HJJeAIDaElX_e8_E2 + + + + + + + _14033480492370290249 mLyMqhhnK6n0OQstUYG1v + + _2654435881 mh8F2krMXRlx_4xzTdoOU + _14033480492370290249 mkA9GKO_6AMEHDxbOk3Ga + + +1./4. mh8F2krMXRlx_4xzTdoOU + + + + + miz1KMizYV2R1rRtcNjOS + + ml0hurHdmF0d85GpxvtHx + _14033480569961022451 mldBjQcmGr8eIRD1GvcbS + + + + const cv mckUV16HU9sHm9uZdiCqS + Point2f &_2654435881 mevXm56_YBOEgMhtXHLr_ + + + + + + const mBduW7dqSuFrUAvwh7kHo + + mKPdnS09u_wtngxINal4U + _16985942626542851460 mldBjQcmGr8eIRD1GvcbS + + _2462542741146301388 mUXyv8dbk5ppT_acPhWw1 + + 0 maY4wzN767Gym8jISz779 + + + + + + ,_2462542741146301388 miRDtKlwqk8TF7Sw9l2PW + + + 1 mrDmgRp9h0Dh4BUsSXIlh ,_2654435881 mEFEjzuP6MMi7DCTCZFS6 + mlTXHwu3F3CXHHjryOJHR + + + + + + 0 mXktWNzMmHZAFNamlC6GA return false mYCDBBfn03HaGvoHBxAMq + + mAYXYBgyHj3X_Dd2pJZFe + + + _16985942626542851460 mMULkK_hCAwRUBiSrD2p1 + _2462542741146301388 mgFSwG5Qfn_BLmntY2X0C + + 1 mgbhB0EhABmFE4YiYt_F7 + ,_2462542741146301388 mZO_0K9kNXGE4qJdhidUD + 2 mgbhB0EhABmFE4YiYt_F7 ,_2654435881 mi7RcOMDzpCM_fd0YYDqB + + mlTXHwu3F3CXHHjryOJHR + + + + 0 mno1HJJeAIDaElX_e8_E2 return false myrZFqGRBYNF96ParCD6U + + + + mKPdnS09u_wtngxINal4U + + _16985942626542851460 m_IHI_fVc_q1bZjzyVqrm + + _2462542741146301388 mJF_EsQxNKzgNgkUPkSWC + + + + + 2 mr3z8JHQwMcj2xXE4THD3 +,_2462542741146301388 mr6dwZ1e1YrZk_9VHOVOR + + + + 3 mrDmgRp9h0Dh4BUsSXIlh + + + + + + ,_2654435881 mswZzmsb_awITT3YY34kR + + + mO2HwsX6Gi0Nsj_ziKTKW + + + + 0 mi_qPWMeKXy2V35xlgf6U + + return false mYCDBBfn03HaGvoHBxAMq + + + mgeJSmXLhlP6TNXhqZxir + _16985942626542851460 mQQpcOreXo7BwJDtiLf6W + + + + + + _2462542741146301388 mr6dwZ1e1YrZk_9VHOVOR + 3 mrDmgRp9h0Dh4BUsSXIlh + + + + ,_2462542741146301388 mye5VOdwJN7t9cn3K3k8A + + + 0 mRfKMxlL2tWQuVdK1eEze + + ,_2654435881 mevXm56_YBOEgMhtXHLr_ + + mBgtqJZzfIHrUcGoHAQCw + + + + +0 mK9SI2tuEHd6tqoKSYbJi + + return false mMU0oJjiwMSWER83Yoiud + + + + mzKNJLXvtvNUiRlFdYl86 + + + true myrZFqGRBYNF96ParCD6U + + + + + + + mdQapdU_WoQv_sTc08Goq + + cv miUQ782fOUPhRLSezoKaH + +Point2f _2320218127778479373 mWGK5Hy854bE4U0Mg0Ybu + + + + + +const mBduW7dqSuFrUAvwh7kHo + + + + return _14033480492370290249 mVlbuMLWi_vwpED0hDKIw + + + + miz1KMizYV2R1rRtcNjOS + + + + + mmcPNoeYt4rZGfwjHpq3k + _2462547792112398716 mZ1vlGA1DxtdKm7CKLuCu + + + + const mYwjl00gOK3Vja3UkLMIP + + + + return _3979714351743309560 mVlbuMLWi_vwpED0hDKIw + + + + + + mcBnPnpY1bM8uBYh6HUzl + + + + + + + mMdtcRR7f77NuQu_fr3jJ + _12796226555186336887 mlQFK8bzD5oJXCxBJV7sY + + mX_72QhckNqIVHutc7sQK + + const + mYwjl00gOK3Vja3UkLMIP + + + + cv mAvRcTPhbmN2xPSE_k1Fp + + + + + Point2f _11093821929003 mGGBlKcUhaQe41o1BnIkF + _2462542741146301388 mUXyv8dbk5ppT_acPhWw1 + + + + + 1 mgbhB0EhABmFE4YiYt_F7 + + - _2462542741146301388 mUXyv8dbk5ppT_acPhWw1 + + + 0 mr3z8JHQwMcj2xXE4THD3 + + + + mh8F2krMXRlx_4xzTdoOU + + cv mHpaYXfOsuVr3FUay39Ni + + + Point2f _11093821929001 mOjeFEIfCRgh8UuNv025K + + + _2462542741146301388 mye5VOdwJN7t9cn3K3k8A + + 3 mnhWVfz3zH1VWcyQIB9k8 - _2462542741146301388 maw3RyPThWckVCHfhwxdL + + + + + 0 mepnG7ntKnXufkqRWW9z6 msMAjv0u65PTGuZJqjppv + + + + + + + mYJJZNT6RsQUQcGvcjw6s + + + _46082576164771657 myDhGU99kOFzHFv3QjOyw + + + + fabs m_IHI_fVc_q1bZjzyVqrm +_11093821929003.x * _11093821929001.y - _11093821929003.y * _11093821929001.x mX_72QhckNqIVHutc7sQK + + + + mYCDBBfn03HaGvoHBxAMq + + + + cv mT5QkV9DFX1GDx2hwjESN Point2f _11093821929897 mX2gazk4jNHcV_njxWdEu _2462542741146301388 mUXyv8dbk5ppT_acPhWw1 + 1 mRfKMxlL2tWQuVdK1eEze + + + + + - _2462542741146301388 maw3RyPThWckVCHfhwxdL + + + + 2 mBoBygdTxOAro2IxSXLIy + msMAjv0u65PTGuZJqjppv + + + cv min5lKhSVWtXKx_RlVkNq + + + +Point2f _11093821929899 myDhGU99kOFzHFv3QjOyw + _2462542741146301388 mUXyv8dbk5ppT_acPhWw1 + + + + +3 mBoBygdTxOAro2IxSXLIy + + - _2462542741146301388 mZO_0K9kNXGE4qJdhidUD + 2 mBoBygdTxOAro2IxSXLIy + + myrZFqGRBYNF96ParCD6U + + + + mdtPDcYitAJmuptZI5zFq + + + + _46082576164771656 mRUhvrauugCIk8ZFUtFF5 + + + + + + fabs mMULkK_hCAwRUBiSrD2p1 + + + + _11093821929897.x * _11093821929899.y - _11093821929897.y * _11093821929899.x mXktWNzMmHZAFNamlC6GA + mv0LWHXRSvGJF76ckeLfO + + + + + mvvh6qusT2GXh0DkHopPr + + mNQC69AzhHy9jDSqnR4rG +_46082576164771656 + _46082576164771657 mjUzUDAZSLiFZyxZqKeCh + + + + + + / 2.f myrZFqGRBYNF96ParCD6U + + + + mDHWaCli8Gp2m47qfC6RO + + + + mdtPDcYitAJmuptZI5zFq + + + + + +_16317296749090388849, _16317296749090388848 , _16317296749090380307 ,_16317296749090380306 myrZFqGRBYNF96ParCD6U + + + + + + + cv mUigKFxK8tUu2fyk4rKD6 + + Point2f _10148430786700162661,_10148430786700162660,_10148430786700162662 mbJpyUK6FpvvNSFdbJncQ + + mdtPDcYitAJmuptZI5zFq + + + + + + _3979714351743309560 mMU0oJjiwMSWER83Yoiud + cv miUQ782fOUPhRLSezoKaH + Point2f _14033480492370290249 mYCDBBfn03HaGvoHBxAMq + + + std mT5QkV9DFX1GDx2hwjESN + vector myAWMCcyr9KnmYFUOoI97 + + cv mjLSF2MxFpKug67geZFRj + + +Point2f mxKAKWewVfJZvgXmZSukB + _2462542741146301388 mMU0oJjiwMSWER83Yoiud + + inline mJ1Z8GSPTaJVFODk7UGea + _16985942626542851460 mlQFK8bzD5oJXCxBJV7sY + + + + + cv miUQ782fOUPhRLSezoKaH Point2f _175247759514,cv miUQ782fOUPhRLSezoKaH + +Point2f _175247759517,cv miUQ782fOUPhRLSezoKaH +Point2f _2654435881 mX_72QhckNqIVHutc7sQK + const mXUfd1VRZJk7TgY4HxOJN + + + + + mKrNzQ9o2OYPnNNMCiAE3 + + mMULkK_hCAwRUBiSrD2p1 + mjRKZlohcMYNnjTvtQdAO + + + + _175247759514.y-_175247759517.y mK9SI2tuEHd6tqoKSYbJi + + *_2654435881.x + mlamOYHCP2faX0Lq_03Ax + + _175247759517.x-_175247759514.x mK9SI2tuEHd6tqoKSYbJi + + + + + *_2654435881.y + mMULkK_hCAwRUBiSrD2p1 + + _175247759514.x*_175247759517.y-_175247759517.x*_175247759514.y mX_72QhckNqIVHutc7sQK + mi7RcOMDzpCM_fd0YYDqB + + + + + + / sqrt mlQFK8bzD5oJXCxBJV7sY + + + + + + mjRKZlohcMYNnjTvtQdAO + + + + + + _175247759517.x-_175247759514.x mK9SI2tuEHd6tqoKSYbJi * mQQpcOreXo7BwJDtiLf6W + + + + _175247759517.x-_175247759514.x mXktWNzMmHZAFNamlC6GA + + + mMULkK_hCAwRUBiSrD2p1 + + + _175247759517.y-_175247759514.y mevXm56_YBOEgMhtXHLr_ + + + * mQQpcOreXo7BwJDtiLf6W +_175247759517.y-_175247759514.y mjUzUDAZSLiFZyxZqKeCh + + mno1HJJeAIDaElX_e8_E2 + mv0LWHXRSvGJF76ckeLfO + + + mccmI7w001g5ij0yS_Brh + + + mUJS382SpQZsi10CwBsIS + + + + mVlbuMLWi_vwpED0hDKIw + + merwTemrIm1u92wWr78Ta + + _6617398332792794799 m_IHI_fVc_q1bZjzyVqrm + cv mT5QkV9DFX1GDx2hwjESN + + + + + +Mat &_175247760140,std mS3XAgUx15FZSKmqI0EH2 + + + +vector mneuHdaa4v6NnVM25bgXO + float mgjPUJwxp8V34r5ZRwn7u &_706246330550423 mi_qPWMeKXy2V35xlgf6U + + + + mh8F2krMXRlx_4xzTdoOU + + + ms4jntDGIeDxNRjsn2Eq7 + + + + + + _5695532316837479313 mK8B3zN6mQAB0xYXFlxGO + std mckUV16HU9sHm9uZdiCqS + vector mcuNgJDAvPmo9ozTKSv_U + + + float mnbIWy6z9Pe9uJP5EqsFX + &_706246330550423 mK9SI2tuEHd6tqoKSYbJi + mbJpyUK6FpvvNSFdbJncQ + + + + + + + mS1cTnkFkfP7nyOzO1oR1 + _18048540700028965067 mMULkK_hCAwRUBiSrD2p1 + + + + + + std mHpaYXfOsuVr3FUay39Ni + vector myAWMCcyr9KnmYFUOoI97 cv mHpaYXfOsuVr3FUay39Ni + + + DMatch moHThLiVDw2yJeZ0EL9So + + &_6807036698572949990 mXktWNzMmHZAFNamlC6GA + + + mh8F2krMXRlx_4xzTdoOU + + + + + + mRnaYj0YvtF5IFOqZNiP8 + mv0LWHXRSvGJF76ckeLfO + mDHWaCli8Gp2m47qfC6RO + + + + + + mMU0oJjiwMSWER83Yoiud + + + +#endif + +#ifdef _17894887532289205286 +#undef myjt6mvkBkZmcOCpyWae8 +#undef mQ166eMFGfLjI1H4bMVQe +#undef miyk4IOFGYjcht0QF2wuj +#undef mL2_sNDksSshctgjHcO0q +#undef micZoto6r5upaMpq4NOR0 +#undef mVBw_rTkATYMOTRmsNe_B +#undef mksbF6by6qnptUpJcoS3c +#undef mHUowwXXMZqRohhPDQTpchWpMh75A_l +#undef mkB7YCOyG7pVkQ21h6On1 +#undef mX3vnsHlXLfRZ9bkxHA4V +#undef mBQ_c7B8rm3Q376o4iCCH +#undef mFmocU8IArOdg_KCyx_1c +#undef mkweV1NTTzZIMacsJnxiA +#undef mGHRNb00IOd9kbU3Lipf_ +#undef mFN7fRxfE_MjqHWBvjBUL +#undef mXhT_hgo_Q16Rxj01zJwG +#undef mqFhGQTAKYEhUuYwI3_Dw +#undef mc3w8tNmNpzQESKqferPh +#undef mUp6tkZSOAEVx5brNaoy0c3R22aukfY +#undef my3AH5NdFqRzLJYNB6vD1 +#undef mY1owl0mSAIpnbwzb76u3 +#undef mG_iM1zjmCQm7KvhbwFm4 +#undef moQ6IW1B5Jsb_OMrna8ZR +#undef mvOfIGxmzUATJX7YeHystvcdJ4FftZF +#undef mc2y_S_Ev95jWdPb11shE +#undef mlmbOUrAHG1vv2orsm7LA +#undef mjLSF2MxFpKug67geZFRj +#undef mG68GEth4OtQ_kpzxTW0n +#undef mbxoIBFMXQ55B6ZWf23aIL6xtSHWOwl +#undef mFUlvNRiMyiQh8aP0yuua9fodcHnOu0 +#undef mlpl5UhdUhvGJT2AHA_N4 +#undef maUe0ImzinTwtZsBK0G3N +#undef mTrcEZildAmTFzcNT5WgE +#undef mWSSvsqNssy8ptET_bJkM +#undef mHc5pUtc1Cx5B0yE1HvLl +#undef msUUcxVD5iFm0snrtwlKp +#undef mv0LWHXRSvGJF76ckeLfO +#undef mM4ARjIPwLfdr_qsL8eAk +#undef mGTsJcy5DnwGJP0oULGTB +#undef mB2r0UBRPAxGnYwegALlI +#undef mwvPBY1bmAQpqbBuwi6ST +#undef mMmsNGhTP939mIPZ2iFST +#undef mFVOF_xi70xN52hJqQRiM +#undef mccmI7w001g5ij0yS_Brh +#undef mMSRfewgGl8OvEwbH39eMiRDykbt4YY +#undef mFhdGpKLQ9YjLkrPrpPpZ +#undef mAzZNYMd99RgL7yTvR9_F +#undef ms1aWWjXC6Bx6IN3cqObV +#undef mVyXKFTUS745QGClEsh9X +#undef mZfCNWHGCUXW1bPF9t3Kc +#undef mx6Nk6byNtqIci_JlD5DoWU9LWnOmic +#undef mN6tTuuEVRYPogdijGm4S +#undef mm_uCtou_ENHLI5ABGtcH +#undef mlmFUfuAtC3zBGydeE07t +#undef mP1YvLB8R0up5_mPvG05E +#undef mXy86FpjyFOQYfK0dtSjX +#undef mjUzUDAZSLiFZyxZqKeCh +#undef mCkrrTINJASa6svj4U3ww +#undef mvUZS35MDnhC41jKFsWE8 +#undef mhJLwFMku1e2js5Yx6jyD +#undef mCcIKmeJ3ghGvOeT7FdSH +#undef miau7uedcHUonFBVnbftz +#undef mqrMFksA8anV6GIkIAFZj +#undef mxZFow1EFI7y8IieBTc7Z +#undef mf0xOT_zUoSyjFUCazBbY +#undef mJF_EsQxNKzgNgkUPkSWC +#undef mgfz6VstbB3AtWs29bXPT +#undef mWq2Z1lsS4vkcPUgLkVCC +#undef mUigKFxK8tUu2fyk4rKD6 +#undef mmdgJNaGE2dbCM6TccQ56 +#undef mEmfdY9_peBCjdAfHCwdK +#undef m_dRf8IJ7nmGssthXyxJS +#undef mKEVUtf4lfr9tym6iQC8HtOfdk7IPoC +#undef mlamOYHCP2faX0Lq_03Ax +#undef mRnaYj0YvtF5IFOqZNiP8 +#undef mN612iUqNRzAkEsrL9JSchf_C8zS6pB +#undef mr6dwZ1e1YrZk_9VHOVOR +#undef mTj14DRd7xgEPvsp5xhPs +#undef mZO_0K9kNXGE4qJdhidUD +#undef mLlx0xCI1E_Kz6hL9P6CXiMl5tQH7_v +#undef mzJ7kyFQ9KR52c3n9YP5z +#undef mGPxw2el7GMZwZxboGCCbFV1WDOW1vO +#undef mO81o600raQdighmjv_frOzRKuHZn4i +#undef moQz60zhJBclWV_HhciQg +#undef mZ_2hNn2gGqPy6Ufj7BEj +#undef m_Mi4LfqL3N2Mqiwlopku +#undef mMhuNQp5krT8JteGvDK0caUZHSR0KnN +#undef mN9g4ghokslRh16yV8uja +#undef mF2LRl5jVA9F0DGGB8XA4 +#undef mzodJn19KUZrR1nqN0_WM +#undef mYZvytvZoNt2UuLxQ9UIj +#undef mZ6DkyNJTg9K_GWPNvui7 +#undef mpjNkDPvLbegN6jypYDsrso16s5FaxX +#undef mYQYU9Rh8MEEEKdf7havV +#undef mg9u34KlnZTaOu3rehQ2vwSDNrcdg6X +#undef muO2JKFnj8ckdywXF_syA +#undef mMULkK_hCAwRUBiSrD2p1 +#undef mS3XAgUx15FZSKmqI0EH2 +#undef mnODdIJiXbJxgUNOnnK7Q +#undef mr2LPTSpds2mNLryLeBNk +#undef mi72YIz1J1bS8NQxGg9SU +#undef mi_qPWMeKXy2V35xlgf6U +#undef mrmAnriVNWgIYgEGfaLki +#undef mk7v9nc3jEPLlniefUsH2 +#undef mQQpcOreXo7BwJDtiLf6W +#undef myjbV3m7yafW0OdiN6vt5 +#undef msoBOmJRxRp6ahCxunFVE +#undef mDlUKBPzOfrAfFwjb9nhp +#undef mVrCVBh2kC_7hyuvhHUDh +#undef my0vyg3fFxA29yj6XkVq9 +#undef mauxaOW9MxCZE4anht2sd +#undef mHRl5FqpS347un79ntw65 +#undef mrJ_YPPVIpp8SUzYb8Cny +#undef mXNuNryuGZXgiIQTL_gnIEU7QTl22LL +#undef mcyISUB4lnJEw_gJVYaVx +#undef me14G4J4dPr4E2p39YdUL +#undef m_R8AWS6RGHbghdVlcnXe_gRZVB9kGu +#undef mSzuu0DOCYBrclgJkWher +#undef mWtGMUHY8MC9U688CsQWq +#undef mPQbPFtz79XwWBcOMk2a4 +#undef mKQa3_9CAv9S0vCMW0VYy +#undef mQdhFMfXoGmiFylGSosyN +#undef mwUhWVOdu9fDyVZjtEyuZ +#undef myqlssGlFKNiMp4ByT24b +#undef mqWvLlL9dHX0W60DLw0C3 +#undef mNuXRvW5NRIUKjBMfo2LCKPTvD66RWT +#undef mD3Q_6lQefg81tjS09GM9 +#undef mtLxDwO7hU_6urkNqRBHh +#undef mlDlXb15uwaHsRhXukXLAhFE3SG2enz +#undef mUaMMT_3w_3sXjqFPvJ2OYLiwngOJEA +#undef mI162kb4SdQzSCWMoQLFu +#undef mQTtOc2wBdPlhUpHJs80J +#undef mvV7vhwmLWYXCorBaZ70t +#undef mlpjKECyQS9giLDqooMp6 +#undef mH83V9yQZ4TlJHtn2Baef +#undef mgIVV9mFMfUaz2AE0Fxyu +#undef mhdGkHwE8CFjml1_fUOhb +#undef me1RdxjH4BmhsvUgZmJ_n +#undef mr6cSlSrgFLMCsweHAbI4 +#undef mMAmCE1MCdSdMSOx9vC1D +#undef mBgtqJZzfIHrUcGoHAQCw +#undef mWGK5Hy854bE4U0Mg0Ybu +#undef mfDJQZQ0abSS_V3bsHBhu +#undef mw6boItfhSsRCkohfG04h +#undef mnEte4qGIA5oly0MUXQYO +#undef my44kvOVt4gJv5GuZhk67 +#undef mdTyVzgFy4_0UFy9GimmM +#undef mV1XXE5UPf1brn2rkEd_L +#undef mZIakbFljtx2rPEKsHIUr +#undef meOQ4s6GwH6J2yIgmeqpqouma8a5KzW +#undef mOYCJmLCpengU1n52_VC1 +#undef mAUsQNLzfNsxysaIjhygG +#undef mBnZZWS5e6tIqudWqd2TV +#undef mzck48t73Ct4PoCk6X5U0 +#undef mY0dqBtGIQeIDQkZWTVBa +#undef mFsqaYli8AXA8muR2taiTp7sZbdSAX0 +#undef mG72KqqPMnk0IUhAG2u6X +#undef ml0hurHdmF0d85GpxvtHx +#undef mMueqb_bFx6h1Dq5FYdLd +#undef msiqIfe8Aci2FIHOTIR3qsdKyqc9jUO +#undef mHfbG04KVjXb9X6NTnYJx +#undef mYURv805DtwXMB3i00wLkIXPqG17WHq +#undef mPqvnNfD_YckjKYWwhuzN +#undef mm62JE4dDW7X3KavKHbI5 +#undef mV30F6ZLorGiUeM_GWQkZ +#undef mcBmuF9mL0hTY7DOpmPHFAEGhxNVxEB +#undef mD5y_1TnUkVuc3JjtY7dn +#undef mLP6hNXpqqY5I3o36W_ic +#undef mQdM1luYGOgqwO8qCRqHw +#undef mBE2Ch4MzRWlScFuN5fWd +#undef mV1zDLskEjl50MSypaDfGpryKBimJE0 +#undef myDhGU99kOFzHFv3QjOyw +#undef mPpNPETq3POeSoH8kpc6R +#undef mrzDBf2HcFmL0H4o7xP0U +#undef mFcbmmAe1Xn3sAcXtcGcG +#undef miUQ782fOUPhRLSezoKaH +#undef mIwuDmZOrznyrmkNgeDm5 +#undef mPEXBE7IFNwhGqfhhF1Qx +#undef mkq4_nxl3S0Jzm77lyTd6 +#undef m_IHI_fVc_q1bZjzyVqrm +#undef mE2zjQ8GOuKnFA2vXxQic +#undef mi9jnuzci0KtruYHVs0tu +#undef mKHaP0HbmD6AONuLTcuMC +#undef muMgkskJtb7MY1kf4Zrs4vfmhNVvU_q +#undef mYCDBBfn03HaGvoHBxAMq +#undef m_ZF9BdGj3tNbqnOuJlx9 +#undef mXXqlktbFRNtTuOoWVQQz +#undef mhWau1QHFsGG_CriJhik5 +#undef mUJS382SpQZsi10CwBsIS +#undef mMU0oJjiwMSWER83Yoiud +#undef mbH_1pmFzWdjvkWJbpHqf +#undef mC5vSuqRiLThyQmuBUrzXxhUuu_8T75 +#undef mKh4dQiWjiAVc2BUxgn1y +#undef mRNPT9tKM_gciYIBVxn_nAJvoU_zc7C +#undef mckUV16HU9sHm9uZdiCqS +#undef mny4XFDXdGKYewM4vUxvP +#undef mk4wB1UVM28QkMlir6zEU +#undef mIN3LXmA7ud1jyId9hD40 +#undef mswZzmsb_awITT3YY34kR +#undef msnQH2BEy39pSSh4Y5hGv +#undef mtyFmebtnPJYKn14LQZwF +#undef mya3I5vmc6etS2JR5W6jo +#undef mo0GXa6qmmi7aAU0xn_QX +#undef mPWHC75Hqqrxt2nHh19dD +#undef m_y5RXkWzthqVfeqHkEtF +#undef mBT8ErdK0daSMkfKeCyAT +#undef mdpd3Q1oSIMShIRkW3i0K +#undef mZdgMotEoyi1ylK3IVBKn +#undef mobeMv7_qVCDXm6ruXQdo +#undef mHoPFX2LlthArVJ80JzTW +#undef mB0eV_Ein7D8DtRR6R9PD +#undef mtM4ibcoFMNRakQm9MNch +#undef mBiKmhgRt19wSzQRtbfdd +#undef mzKNJLXvtvNUiRlFdYl86 +#undef mTSqEnCp2F7oGsXocn00b +#undef mJpQJFURUc57_1UwCTPvr +#undef mmM3130WhDQoYKhJxw_Xq +#undef myQQZvECyjg3O56KOcG4I +#undef mQ_6zyV0kv3_EINtoxDwr +#undef mgjPUJwxp8V34r5ZRwn7u +#undef moxd8QZOAVwktUc3FByc5 +#undef mkZ7Kqcf4wqU2aCyvQcrQ +#undef mnbIWy6z9Pe9uJP5EqsFX +#undef mmo6NathgJbdjMSVDtQp7 +#undef mPE7IBy0IPVAmmHy8SjBtbGdzyDGZ5w +#undef mkzSZJDew824aa0gKauM6fZ2VRvPUyZ +#undef mE5LTP2zTjEhjnDFXjSev +#undef mDMt1ZTB93OOf720760yl +#undef mGGBlKcUhaQe41o1BnIkF +#undef mYwjl00gOK3Vja3UkLMIP +#undef mfhySFU1HsIBJqLiJ327y +#undef mdMUZEqfsNJwzXmiUDunr +#undef mvvh6qusT2GXh0DkHopPr +#undef mwDlDseBie2pxcHRhfDFc6S1RpokmPB +#undef mByXC_NAGVGzCcmUEv_c9mAYK8t5jBN +#undef mECAa9sgu7USEtdxuKwtx +#undef mQobuDSVt58FPnfszcDJr +#undef mxXk248Fd2GKf_LFcesfZZnoIqLr72r +#undef mAg3pV2BnIdWvGDAHS6XN +#undef mPiXWtTRtV3niuCzxZfTh +#undef myVYsDT7OYd8XctOkLKTo +#undef mGEiFRHCGbRjviI6dzqMDlmzCs3ik32 +#undef mpPs91o0LDjQVAG6h6drD +#undef mLOayNi4OeqI5xdlV9zlg +#undef mkaV1FlCCNXxwPQiRYst6 +#undef mHZ3j6aqYhTYV3deaGL88 +#undef mAuUYEOm2BbWF6IJcF4pn +#undef mukY8albO2VdJSsWPXwW4 +#undef mBduW7dqSuFrUAvwh7kHo +#undef mIn9uf1QzYnCvpv2LYrlu +#undef mT5QkV9DFX1GDx2hwjESN +#undef mxppI9IWo6ETE7Xy0HpdgXksc2hcHJy +#undef mG7JUSOE49gtRFHxIAfjvLJ8YSx2vnS +#undef mjvoRhqdFUGIOW_TT7ao4 +#undef mXXlmh1qZ8LrEX5JPWAsH +#undef mwmLd9BQX0zGRjBZe4T9C +#undef mgLrtHcg4MaTZannI6pUB +#undef miYs8DgrLKKO1jnVddQve +#undef mMdQn4APCAlSzpf1HfuMv +#undef mhtNTtn6MOGdZh5y0qghw +#undef mTiMXJ8zZxs8kJip50BA1j8OuF8N0w8 +#undef mEgVjleirMsmEf67oPlWfaeIxUscFp7 +#undef mBPuuAO5RqtP8G4TYdodjmRE3B0xQ6t +#undef mysmqBdEdJc6LM1WnLE_V +#undef mUJURq86_xVTlgOXdOyA2 +#undef miT4zgLZfSmtvyPhpk9eT +#undef mwTuETA6l5LkFRM2jsRui +#undef mC4jgxUk9IqoFVn3WtN5d +#undef mQ1Teamvbt5lB49LZfgOd +#undef mcrwhsXaIF63Fh7eMT4MG +#undef mpAPhqqYK8YmM6ja9Ozwe +#undef mbB0o_TePQ_CM_sK1uVb2RkhYds_ArW +#undef mvx4iiBtbFTCCgKNBio6WX3hcEpFwdC +#undef mJ1Z8GSPTaJVFODk7UGea +#undef mVhYWVEiqGfed8jjftJ1e +#undef msMAjv0u65PTGuZJqjppv +#undef mH4uv54rqCTTFcGPjj9RxyN3HpzpG5W +#undef mQcY6IgOnfAeJqQU_d7C3 +#undef mlTXHwu3F3CXHHjryOJHR +#undef ms4jntDGIeDxNRjsn2Eq7 +#undef mSye5PefiM2uFq__QqZRQ +#undef mWtLIoQj1M2jOblvHvjzH9m9WaZ2XpZ +#undef mlOdFLXaGOYUjivxD9wX5 +#undef mppxouGr5NqFj1UhsaPX9dF8rM6HHrV +#undef mHhK4Wq8bVz54aZfcRF8o +#undef mi7RcOMDzpCM_fd0YYDqB +#undef mfDtAZ5HSHH1oUlJGGIlZ +#undef mowePBrYh_dGcjl9h5o4f +#undef mBIq_DVFgixqI_xjwE1SS +#undef mvSkbHm3CGl2q0Wj6tYybdRsrCkavDX +#undef mxolFRMUnTdXqvO1SqV6i +#undef mUlwEStSUJv18SInCzLuG +#undef mXet2VlYvMLSAhibYw9gK +#undef mwPtUuZDgsaCWLEN2d2o8 +#undef mBjWU34yTNTqvHVW92wJn +#undef mlQFK8bzD5oJXCxBJV7sY +#undef mqUS1HkZXOdPZoz5hxZz1 +#undef mMdtcRR7f77NuQu_fr3jJ +#undef mGJoExPsp9LQpgvTNdOhH4AqaFjFPrq +#undef muytsPxMUgB_P68ddaMn1 +#undef mepnG7ntKnXufkqRWW9z6 +#undef mSClDmTu1RahB8jJ_bvRI +#undef mrJuVHPe96ExiggCdsmDG +#undef mmBYorUTU9skF2KihFJIh +#undef mlVwVAuHWeENUvSO7HWkMzRa_tFxENm +#undef mI34DveCaN9DNYZDxYuHUgIYz0Ne3X4 +#undef mMmHBiAaI0zzV3ljKxcO_ +#undef mzND_PZXt4nmzDFaIG26B +#undef mJ3X_4tWudQC9mG0a80Hc +#undef mPXEWgPN4wD4VKJTcqH1a +#undef mIqdr3spVPvnWuvEuHB7u +#undef msIKQo53AV0IVzGjNlewV +#undef mAj1mWKjblCSJ4vrCIDPCtBbixR6G_I +#undef mH0rzhLZkT82t7fN6IGVkmpqxn9y3U6 +#undef mzxXooop26qxQLwrV55gp +#undef mX4p7HQLaHppxdyC5eyULX5E8mE9RwH +#undef mXMEXB9R3ROHfrrdWZS6b +#undef mcf5z6J_0Bh5xYToLm68d +#undef mK9SI2tuEHd6tqoKSYbJi +#undef mDmPOuFvKpCYJNc4gEu5QXlqXd8CFgO +#undef mdurnpS44gFEyG3iAVlcv +#undef mpv8yiIU5OTNWCY0FR3jr +#undef mMoHqiu6JwSK0lIvbHHDB +#undef mqlgGcrNPonBjZZxdOMc1cfXZa22u42 +#undef mi2dBh8k9FLez0sEZ5dkY +#undef mROJxX9wjLxUZjYd74YpQGRptuC2PN8 +#undef mvRNdf8YwY3ixuLJl_rX8 +#undef mno1HJJeAIDaElX_e8_E2 +#undef mpGVq4mq1kqAkSGwAxR2eT1acboA8o0 +#undef mIm_ycsoau8_tLNuooXJK +#undef mNwbGd9CaRdW7etMDVp9l +#undef mbuu0EnGVF53w0618opIs +#undef mETgsfs6WSP_BZRACs15T +#undef mZXxCmMdUx7aas2_c3ufJ +#undef mnLfX8gryrIwz9uIwIzOO +#undef mpEJbtQk7kAn4LAsjEHOWfzqi0wouBy +#undef mLg1ngIK40sRfE7UPLjO9 +#undef mqCAZWuyUH5kqcH_GFI_H +#undef mdOAGhzyWotAgsCpitefm +#undef mkjkEVFnl42KhUvXppZqI +#undef mDqzaA5LSZ9P5s2CU9mUo +#undef mZsASRf25kFGZKNUrTWAt +#undef mwH5LvjbwrSytFhP6RqwY +#undef meeew573ex8ktJQTmc61N +#undef mUUq4U1Oqga0d8b3HPyuX8hMxfSRAvG +#undef mK8B3zN6mQAB0xYXFlxGO +#undef maY4wzN767Gym8jISz779 +#undef mAYXYBgyHj3X_Dd2pJZFe +#undef mRneWJ109jmANhfUiE4CnpkFXk_Lv2r +#undef mPNfgLFiDt2jD45GRfVny +#undef mX_72QhckNqIVHutc7sQK +#undef mB3meFqYoVLl7CRmENctD +#undef mnCtIlE9OtfFKOHdE3Qow +#undef miDaigpLYw0VF_Vn2JqCS +#undef mvHie9HLuNTMQuAtghEHv +#undef miKJsEDuNShma3B8CvEC1aT0P2iZrvN +#undef mJypdKIZMGAY43lYvSQIZ_fAFrKnPPr +#undef mLAThc7eriTzGBeEGc08E +#undef mQF4BsfJECct84XFjjoEU6t3rs75CtC +#undef mnAS1an2qOtGSVDxEnd9N +#undef mK6w4zj_Cfsechu5EkJHm +#undef mLRMpH2S7Q7rgidWYU85G +#undef maRODO7jtDwOXJAQaX38H8DWUojuqcM +#undef mFzTZaNOrvPJ32i9gU3Wr9J28M8DBzQ +#undef mpgKFTVEqPTb5IdYsP2ue +#undef my7F1rl9qUr89NgiItLnq +#undef mye5VOdwJN7t9cn3K3k8A +#undef mgbhB0EhABmFE4YiYt_F7 +#undef mhzwVmt_MX6lld_L8c2CT +#undef mVgUgXBETUT9RYgzaEEvmZjILeuz2W1 +#undef mbJpyUK6FpvvNSFdbJncQ +#undef mO8bpVd2PJ77esnS59E9g +#undef mpZpmaQl_lAQPlcd_urfl +#undef mFm9g1BwxYhrjkokcaPw5 +#undef mN9lZo5JKGU_oWiM5lGVp +#undef min5lKhSVWtXKx_RlVkNq +#undef mrfBUZQ89n2Fq6JbcSj051lgHgxgqmT +#undef mb9AhvnFKiM7PZQgN8AnP +#undef mYCkonaAO4gN81sZ2p0n1 +#undef mmcXqtULH6e3SfUwc9mEozHR6BAeaAK +#undef mRDNvioGRCQx5QFoNyf5u +#undef mZ1vlGA1DxtdKm7CKLuCu +#undef mB6MN9g5xL5nkN5YWag3C +#undef mEalxWU7zo1ATRu2ZVb1P +#undef mcBnPnpY1bM8uBYh6HUzl +#undef mlT_mjpAfCKCfVoralv_O +#undef mlx7mSONcMQHDJGRY1s9Q +#undef mR7UDzpdmNtk0LaVrg_WS +#undef mBoBygdTxOAro2IxSXLIy +#undef mbDazXUVd8HbwiBPwI_Fzq6o77n69h3 +#undef mHMsdkJQIeMorGvCkHQL4 +#undef maAxBoYk8MlyHqFZxz1nB +#undef mo6JP2Hjo1hYSbtxG1tBsHQIY9i4q6x +#undef mWQRJWn48_10aX_qZsR8nxNi9ZbHwvJ +#undef myAWMCcyr9KnmYFUOoI97 +#undef mxFIMAbbLmgFagQqrs_3K +#undef mA4pIiwhfATkxUMZvmMgG +#undef mYbvoZQc6bHx_Fyt_MMHA +#undef moHThLiVDw2yJeZ0EL9So +#undef mk_6Non2n1Nk_IOZFo9It +#undef mjUc6SW5zsycGDua26UpFKAohHGgzZw +#undef mqAW_4Iop6vrpLxkp3WxM +#undef mRfKMxlL2tWQuVdK1eEze +#undef mhN2hPhnFFq5alNSwVOjtfx8xECWu2g +#undef mwhUA7Xg7QgUXMl3iamcW +#undef mRUhvrauugCIk8ZFUtFF5 +#undef mM6XcgUcgIo1UBU_8497N +#undef mbTfdTaC63u_oUxPU581H +#undef musd6mNOqDV_uv4WuoukR +#undef mfhQjb7dYTtes1IJzyWzK +#undef myBNCW9B93fqpNc_ReUd9 +#undef mJqjrZ0Sw_IsRstpA5TSG +#undef mYpMLFLIsCswIhxn8c85k +#undef mRtPBvwiZzHWglctKPmaF +#undef mHV9qHmbImBy3_nGzxW0A +#undef mCfZ3xmjpOoiue_rJZuHY +#undef mAvRcTPhbmN2xPSE_k1Fp +#undef mz_nGm5RRBM5OZvSzyerZ +#undef mH07Fxx1cMYcyiFqHylt1AYLSl1yoct +#undef mu1aRcYPGwwmkdvLrXjWyYkshrNbQfZ +#undef mydHLymMTKIi6ZifSrWI0 +#undef mZ1llnScqJFuPUybkhEyg +#undef mnhWVfz3zH1VWcyQIB9k8 +#undef mnwG4_xdlZA2y_F7AWbcT +#undef miz1KMizYV2R1rRtcNjOS +#undef mEFEjzuP6MMi7DCTCZFS6 +#undef mD07x3flmZMPVC6kwqG6P +#undef mBOsEIVwEao1XJUDJrPZE +#undef mOrwrNhO0dJdd9_VZZyS4 +#undef mGR6SzQWzeL24xknZXFg_ +#undef mnHlLzNOM1EFnPgmTo6jXwnLA_aQ96X +#undef mevXm56_YBOEgMhtXHLr_ +#undef mHpaYXfOsuVr3FUay39Ni +#undef mbWCzXPWiU5UnehGRQjZW +#undef msKjB5qmFwUklNSf8OzEo +#undef mjRKZlohcMYNnjTvtQdAO +#undef mgeJSmXLhlP6TNXhqZxir +#undef mplnjROdhBiR41oAbuFMA +#undef mStmvG8q8rxZk4ojH0SMY +#undef mpbd2v5irTp0SZEDScz2P +#undef mtcKUO4neYNCPizxaLKZc +#undef m_dk3EP_dRaChCeAYkjUT4mGB6eHLjG +#undef mBa_FkhJWkxczFPmuwrTO +#undef mjF6J0Tk42CCIJjZoCAkN +#undef mdM3yiUQKhlGh0UTgxGcr +#undef mCOT8cq5e07IauJokKEVa +#undef mbE01jtodeD0XHidN8ZSb +#undef mrRPX0yiW6moj3IJis656 +#undef mbn4lbSkbx4XRi_23fRor +#undef mKxlK2zseKVjqTbudIc3N +#undef mAz18novAd1i1I1IpmgBW +#undef mrDmgRp9h0Dh4BUsSXIlh +#undef mnbetEUpLtQdoPk5xCZf8Fw4xc2_skF +#undef ml6Lc_xmRvI28kysuWKYN +#undef mXktWNzMmHZAFNamlC6GA +#undef mYJJZNT6RsQUQcGvcjw6s +#undef mP3125AruRj2p_81GOlEh +#undef mZiH6fOOf1imwiMfiN54uLwlhFttHgN +#undef mgTrILrfg8pPxUuxKEcTL +#undef mM4ZoJ_SnlQoODH2aaK0f +#undef muyiQYiSOQfifaTNSSeCM +#undef mct7Xy21wxRleVXcxtLRh +#undef mO2HwsX6Gi0Nsj_ziKTKW +#undef mt6yjpFiHdHNJRK2EXA4b +#undef mxKgzipjOOx9WW36X6hqYuv2tZVVSjN +#undef mme4iNmyh3d1i2QQNS_2c +#undef mbS9aFrXrV_XN2LWGc9z2 +#undef mifNci4V9xDSn2__VqXAh +#undef mX2gazk4jNHcV_njxWdEu +#undef mrgX6KhYvp7HXnUnI9h7v +#undef mN6IouQCV1G_3AGCPEUFb +#undef mPRlplsRvbEfyTJGl_mKJ +#undef mSSfilJz1l1vrPkNmBbBYOJOOC5eFjY +#undef mpRZBOViMqw9Of7v7FuxF +#undef mtmqH82lzCWNK8m7mQsVB +#undef mhRsTVRq0qS2pWBngwcgU +#undef mGTLHA0VARSIg8ylf7DsN +#undef mfpPxSkQX4iiZk9EocpoP +#undef mTxmfff7IHS0qS8YwYb_m +#undef mnq4f9zw6OLsO0wliBlwX +#undef mMzdeJuOObJEf2uB5uZhp +#undef mw6wQQeGWiN7TOwHChuc4 +#undef mdHMNa42WjKQSBe1HuHxE +#undef mmcpFPtC6G2s0YECGzTZ7 +#undef mltpoGi2HnF2QM48Vhil6 +#undef mX6CEdeimSCykIq3Gne8p4_neWe8haV +#undef mxz6PzKUJzf8QasULgU3i +#undef mAUFdFhd86lS580n0lcXL +#undef mwJQeqKCRIzCQuN1bibyJ +#undef mn5g7mx05lpWzycbp3jkZ +#undef mL53y6DoHHNcMKFrTK859SLdb1UlAs_ +#undef mh8F2krMXRlx_4xzTdoOU +#undef mdQapdU_WoQv_sTc08Goq +#undef mxKAKWewVfJZvgXmZSukB +#undef mY7o1NPY6YeHYwpSxdBEu +#undef mmUKE2NIlpdAbdSvw43EJ +#undef mP7sdPnZQLOU0BFRsWdBb +#undef mgTaMXBV1VgmmBwBtiSZCm3esY_KVoI +#undef mbFqIXS7nGmSWTZUGdt6h +#undef mjoQfe68S5Q_rdrMl0euV +#undef mJu8rH9ch6s8uIUBEA4QJ +#undef maGeX7XTrrGt9WkYY6R6c +#undef mnN8tONujwWIvopGKHc6C +#undef mLWlvpGmo9eeHBf58X3QJ +#undef mb0pptCGbYqOrmLwS1Q5tqzLpheIof7 +#undef mICKnpYrDMnPCPXp4dVqY +#undef mKPdnS09u_wtngxINal4U +#undef mzSNEVeoLA75I9ssO0ENy +#undef mPjJM_xxJfdKpSxL3Dwf6 +#undef muDDe2mbjdikIAPIf9R74 +#undef mLyMqhhnK6n0OQstUYG1v +#undef mI4uvJUMtOHwM9tZ_fQVibhgDcYwIsM +#undef mH9xkXr1In9WhMDYLLAkQ +#undef muaFGlfaFGOXNK4y4UmfE +#undef mneuHdaa4v6NnVM25bgXO +#undef mh7c_3v129zjIHtV8KZ26 +#undef msKzyZlaNaz2l1SzaDpvX +#undef mR9VKjghgaLOMp5P9Zyl5 +#undef mpDqyj5NDVnikUB0G2KXc +#undef mzf6azcCC18atKCW8jv7f +#undef mkNO0_AWxaGk3x9Q2X1v1 +#undef mzViPhIynHrdcovjL0yxX +#undef mJyp2URhtKJ4pT5ukH5s5 +#undef meXTlhfdU7jLZmpkshJCw_8ShhDp_t6 +#undef mCFOlmc2fW4dGKgcXGywjOcbcBURZe0 +#undef mYOgju0IdpiIrPDX5YqfPiMIlBX99iH +#undef mSXKPLrYFE9ulUmIJdgyrdKyR63LaZP +#undef mOSSGrURc1IqPIl85mdrs +#undef me6pUE9_YClfZKU7x5OifQjPccb94lS +#undef mADzh86bL8pAyHClR1vQ7 +#undef mO4M7EU7PgI62BwLIk4ju +#undef mn6ImA9zACAiMvrI6olSBmJrpXKLoXy +#undef maw3RyPThWckVCHfhwxdL +#undef mKlSl2sIEia_PkLDcBaaC +#undef mih_9WLudSW1kyUGTMFLC +#undef mPXYuzTL9RZjjZA9XYUV9 +#undef mf7PYtifgCp4QRlVsOFRz +#undef mcuNgJDAvPmo9ozTKSv_U +#undef mJ_QtD3j_Hy6klJbnFcoo +#undef mO3Hp1CHWD4lgwYuyxZ85 +#undef myrZFqGRBYNF96ParCD6U +#undef mXO39HQBWo7GF_22EqX6m +#undef mtr8mN19Ounq6OdpTfVSE +#undef mzCpQW3fpqEdo67JRhyP6 +#undef moom6H8LGfVPeEz2uXxHK0Xuxids_EU +#undef mFcgF3IsSMx4O4tc_aIEx +#undef mYYHF0v5IvelyodO3CkWq +#undef mhQFg9mCeHTkil0MxNqFBcMWECKe0mm +#undef merwTemrIm1u92wWr78Ta +#undef miLQiDMenWk2M677vtZJh +#undef mRSe1JGN0drSxJSLXeFPv +#undef mdqEgL_F1rF0PcEYLtdgV +#undef mCGZMd2s1bE8jGVM9cwoZ +#undef mqrdJ5cFacO6oCNOVfBFB +#undef mpI1hFbpLVrw4pYfwhffO +#undef mkHgNy3StwXafrhd2Ce4g +#undef mhAClyNpRo5WfaCqgeyGM +#undef mlNbIP19t8qNuxt2d_OKP +#undef ma4mt6LbiKt84kAFpQxO9 +#undef mlfcVjh0iNdTwwvFkwxuv +#undef mOcjjgyUyDEe51laoqeGm +#undef mNQC69AzhHy9jDSqnR4rG +#undef mKrNzQ9o2OYPnNNMCiAE3 +#undef my9E4sAt6II28meWefBqO +#undef mzZN1INodhXdUd04UijoI +#undef mpP2GF7ujwR6b4IMaTPKX +#undef mN5qlgjY0Pp93rpwmpkp6 +#undef mtnUxtXxOkzROgIud9RzY +#undef mwMforR95PelCmG2YYe4Z +#undef munHuTw8Uzq5NKBMuDnpp +#undef mlK8WIoLNVgqusrN_lRzH +#undef majlOVtmuTRgvUVIcSQvo +#undef mOCoCw9Cs4kbfIBoXaFoG +#undef mclEcmEc3AtXuiRBOKWdo +#undef mSfn1rgQgnURKtReGFFxm +#undef mfrDnoW0Q_MaPPDXklzPm +#undef mFEY6Erk9Df5dSh_F4MeB +#undef mv_DqgxwqCfuDROyXpSIi +#undef ma645_NNZeT5F9wHyADdc +#undef mOjeFEIfCRgh8UuNv025K +#undef mr3z8JHQwMcj2xXE4THD3 +#undef mF6Bt8jugVNRGdi0vvR62 +#undef mlR5zcVB6km7zsMW2j4Aw +#undef mmcPNoeYt4rZGfwjHpq3k +#undef mjNt5YlANSVVhZIAFumjXvIzF2hUNcV +#undef mPR_vJk7xiUA8xxP1FUBt +#undef mvo7wAKdJZhJiiuRM0Hbs +#undef mMfSh_Wk7Uwf6D6ulSZVq +#undef miRDtKlwqk8TF7Sw9l2PW +#undef mqeD2C88v6MotXF1X0ZlV +#undef mgFSwG5Qfn_BLmntY2X0C +#undef mjSHC8mP2XGL723gPEeLJ +#undef mUXyv8dbk5ppT_acPhWw1 +#undef mdtPDcYitAJmuptZI5zFq +#undef mJWt3_nPdSmmWlrKrZnDvgIVZcFsnmO +#undef mXCQxlYZzKjt3aTjx0PfZJRKyQw07xF +#undef mcUP2n_VBuIlxqYqfBL1z +#undef mG1rhlQsW6fk6GBUyGmwX +#undef mTxSy1aUd4rlAPO4PxvQI +#undef mBN4ZxhCXvls3Jdd3Lx6hxm3H0auBES +#undef mUcBD0Yy493w67BU4b_nV +#undef mux0UzK5E31HHJOOZvgNn5ful3aEQGK +#undef mZyhRmr9RDqRn5F7u88VbqOcCvrU5JM +#undef mULWVxWPmB8YP6nVlXdwx +#undef mS1cTnkFkfP7nyOzO1oR1 +#undef mldBjQcmGr8eIRD1GvcbS +#undef mVejSuiipgaso22bYAXA5 +#undef mFvTCBn4KoMBo14t4vfEG +#undef mCANKknbAxy3AZvo6SxVpLmM7bcTDYG +#undef mf6dMfxgoh6cHDHp8Qab5 +#undef mFPW2Q4dl3H89ODxIFAB4 +#undef mByUtXVZly0Au2emMwRAr +#undef mm_UJR0LI9kDIyN2IZsVK +#undef mJt4jiqHrPjmtLt1LXTXH +#undef mYZQL0WZd_roih9lMR5ZU +#undef mbhBlGSXOjQVuXigrQvnU +#undef mVlbuMLWi_vwpED0hDKIw +#undef mbEgSz1MPCDJfiXl8mzvB +#undef mwg2aC9ukDzEK6JpgUq0H +#undef mpDZGxej0afFEZAemXzRj +#undef mII972chYSMVfY7gKjPyP +#undef mGvKMfeWtBDkgZFjtUdcK +#undef mqqKt69glLALpHYtBYVIq +#undef mDHWaCli8Gp2m47qfC6RO +#undef mXUfd1VRZJk7TgY4HxOJN +#undef mFd6DPKb1DowSqilxGTbE +#undef mutvnLqU8rSyuONVmeMRx +#undef mznvSuQ7aBDLolhE4qXYl +#undef mkA9GKO_6AMEHDxbOk3Ga +#undef mknoSWMLUaR06YtBqtgam +#endif diff --git a/src/aruco/markerlabeler.cpp b/src/aruco/markerlabeler.cpp index f48b145..29fbe46 100644 --- a/src/aruco/markerlabeler.cpp +++ b/src/aruco/markerlabeler.cpp @@ -1,16 +1,12 @@ /** Copyright 2017 Rafael Muñoz Salinas. All rights reserved. - Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR @@ -20,17 +16,12 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSE ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - The views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of Rafael Muñoz Salinas. */ - #include "markerlabeler.h" -#ifdef USE_SVM_LABELER -#include "markerlabelers/svmmarkers.h" -#endif -#include "markerlabelers/dictionary_based.h" +#include "dictionary_based.h" namespace aruco { cv::Ptr MarkerLabeler::create(Dictionary::DICT_TYPES dict_type, @@ -41,37 +32,16 @@ or implied, of Rafael Muñoz Salinas. db->setParams(dict, error_correction_rate); return db; } - cv::Ptr MarkerLabeler::create(std::string detector, std::string params) { - auto _stof=[](std::string str){ - float f;sscanf(str.c_str(),"%f",&f);return f; - }; + auto _stof=[](std::string str){ + float f;sscanf(str.c_str(),"%f",&f);return f; + }; (void)params; - if (detector == "SVM") - { -#ifdef USE_SVM_LABELER - - SVMMarkers* svm = new SVMMarkers; - if (!svm->load(params)) - throw cv::Exception(-1, "Could not open svm file :" + params, "Detector::create", " ", -1); - //*SVMmodel,dictsize, -1, 1, true); - return svm; -#else - throw cv::Exception(-1, "SVM labeler not compiled", "Detector::create", " ", -1); -#endif - } - else - { - - - Dictionary dict = Dictionary::load(detector); - // try with one from file - DictionaryBased* db = new DictionaryBased(); - db->setParams(dict, _stof(params)); - return db; - } - - throw cv::Exception(-1, "No valid labeler indicated:" + detector, "Detector::create", " ", -1); + Dictionary dict = Dictionary::load(detector); + // try with one from file + DictionaryBased* db = new DictionaryBased(); + db->setParams(dict, _stof(params)); + return db; } -} + } diff --git a/src/aruco/markerlabelers/dictionary_based.cpp b/src/aruco/markerlabelers/dictionary_based.cpp deleted file mode 100644 index 9a4bca3..0000000 --- a/src/aruco/markerlabelers/dictionary_based.cpp +++ /dev/null @@ -1,290 +0,0 @@ -/** -Copyright 2017 Rafael Muñoz Salinas. All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are -permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, this list of - conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, this list - of conditions and the following disclaimer in the documentation and/or other materials - provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those of the -authors and should not be interpreted as representing official policies, either expressed -or implied, of Rafael Muñoz Salinas. -*/ - -#include "dictionary_based.h" - -#include - -#include -#include - -namespace aruco -{ - void DictionaryBased::setParams(const Dictionary& dic, float max_correction_rate) - { - - _nsubdivisions=sqrt(dic.nbits())+2; - nbits_dict.clear(); - dicttypename=dic.getName(); - if (dic.getType()==Dictionary::ALL_DICTS){ - for(auto &dt:Dictionary::getDicTypes()) - if (dt!="ALL_DICTS" && dt!="CUSTOM") - vdic.push_back( Dictionary ::loadPredefined(dt)); - } - else vdic.push_back( dic); - - // - for(auto &dic:vdic) - nbits_dict[dic.nbits()].push_back(&dic); - - _max_correction_rate = std::max(0.f, std::min(1.0f, max_correction_rate)); - } - - std::string DictionaryBased::getName() const - { - return dicttypename; - } - - void DictionaryBased::toMat(uint64_t code, int nbits_sq, cv::Mat& out) - { - out.create(nbits_sq, nbits_sq, CV_8UC1); - std::bitset<64> bs(code); - int curbit = 0; - for (int r = 0; r < nbits_sq; r++) - { - uchar* pr = out.ptr(r); - for (int c = 0; c < nbits_sq; c++) - pr[c] = bs[curbit]; - } - } - - int hamm_distance(uint64_t a, uint64_t b) - { - return static_cast(std::bitset<64>(a ^ b).count()); - } - - bool DictionaryBased::detect(const cv::Mat& in, int& marker_id, int& nRotations, std::string &additionalInfo) - { - assert(in.rows == in.cols); - - cv::Mat grey; - if (in.type() == CV_8UC1) grey = in; - else cv::cvtColor(in, grey, CV_BGR2GRAY); - // threshold image - cv::threshold(grey, grey, 125, 255, cv::THRESH_BINARY | cv::THRESH_OTSU); - - std::map > nbits_ids; - //for each - for(auto &bitsids:nbits_dict){ - int nbits=bitsids.first; - std::vector ids; - getInnerCode(grey,nbits,ids); - if (ids.size()>0){ - if (ids[0]!=0){ - nbits_ids[nbits]=ids; - } - } - } - //how many are there? - - if ( nbits_ids.size()==0)return false; - //check if any dictionary recognizes it - for(auto nbits:nbits_ids){ - const auto &ids=nbits.second; - //check in every dictionary - for(auto &dic:nbits_dict[nbits.first]){ - //try a perfecf match - for(int rot=0;rot<4;rot++) - if ( dic->is( ids[rot])){ - // std::cout<<"MATCH:"<getName()<<" "<at (ids[rot]); - additionalInfo=dic->getName(); - return true; - } - - //try with some error/correction if allowed - if (_max_correction_rate > 0) - { // find distance to map elements - int _maxCorrectionAllowed = static_cast( static_cast(dic->tau()) * _max_correction_rate); - for (auto ci : dic->getMapCode()) - { - for (int i = 0; i < 4; i++) - { - if (hamm_distance(ci.first, ids[i]) < _maxCorrectionAllowed) - { - marker_id = ci.second; - nRotations = i; - additionalInfo=dic->getName(); - return true; - } - } - } - } - - } - - - } - - - return false; - } - - - bool DictionaryBased::getInnerCode(const cv::Mat& thres_img, int total_nbits, std::vector& ids) - { - int bits_noborder = static_cast(std::sqrt(total_nbits)); - int bits_withborder = bits_noborder + 2; - // Markers are divided in (bits_a+2)x(bits_a+2) regions, of which the inner bits_axbits_a belongs to marker - // info - // the external border shoould be entirely black - cv::Mat nonZeros(bits_withborder,bits_withborder,CV_32SC1); - cv::Mat nValues(bits_withborder,bits_withborder,CV_32SC1); - nonZeros.setTo(cv::Scalar::all(0)); - nValues.setTo(cv::Scalar::all(0)); - for (int y = 0; y < thres_img.rows; y++) - { - const uchar *ptr=thres_img.ptr(y); - int my= float(bits_withborder)*float(y)/ float(thres_img.rows); - for (int x = 0; x < thres_img.cols; x++) - { - int mx= float(bits_withborder)*float(x)/ float(thres_img.cols); - if( ptr[x]>125) - nonZeros.at(my,mx)++; - nValues.at(my,mx)++; - } - } - cv::Mat binaryCode(bits_withborder,bits_withborder,CV_8UC1); - //now, make the theshold - for(int y=0;y(y,x)>nValues.at(y,x)/2) - binaryCode.at(y,x)=1; - else - binaryCode.at(y,x)=0; - } - - //check if border is completely black - for (int y = 0; y < bits_withborder; y++) - { - int inc = bits_withborder - 1; - if (y == 0 || y == bits_withborder - 1) - inc = 1; // for first and last row, check the whole border - for (int x = 0; x < bits_withborder; x += inc) - if (binaryCode.at(y,x)!=0 ) return false; - } - - //take the inner code - - cv::Mat _bits(bits_noborder,bits_noborder,CV_8UC1); - for(int y=0;y(y,x)=binaryCode.at(y+1,x+1); - - // now, get the 64bits ids - - int nr = 0; - do - { - ids.push_back(touulong(_bits)); - _bits = rotate(_bits); - nr++; - } while (nr < 4); - return true; - } - - -// bool DictionaryBased::getInnerCode(const cv::Mat& thres_img, int total_nbits, std::vector& ids) -// { -// auto toInt=[](float v){return int(v+0.5);}; -// int bits_a = static_cast(std::sqrt(total_nbits)); -// int bits_a2 = bits_a + 2; -// // Markers are divided in (bits_a+2)x(bits_a+2) regions, of which the inner bits_axbits_a belongs to marker -// // info -// // the external border shoould be entirely black - -// float swidth = float(thres_img.rows) / float(bits_a2); -// for (int y = 0; y < bits_a2; y++) -// { -// int inc = bits_a2 - 1; -// if (y == 0 || y == bits_a2 - 1) -// inc = 1; // for first and last row, check the whole border -// for (int x = 0; x < bits_a2; x += inc) -// { -// cv::Mat square = thres_img(cv::Rect( toInt(float(x) * swidth ), toInt(float(y) * swidth), swidth, swidth)); -// if (cv::countNonZero(square) > (swidth * swidth) / 2) -// return false; // can not be a marker because the border element is not black! -// } -// } - -// // now, -// // get information(for each inner square, determine if it is black or white) - -// // now, -// cv::Mat _bits = cv::Mat::zeros(bits_a, bits_a, CV_8UC1); -// // get information(for each inner square, determine if it is black or white) - -// for (int y = 0; y < bits_a; y++) -// { -// for (int x = 0; x < bits_a; x++) -// { -// int Xstart = toInt(float(x + 1) * swidth); -// int Ystart = toInt(float(y + 1) * swidth); -// cv::Mat square = thres_img(cv::Rect(Xstart, Ystart, swidth, swidth)); -// int nZ = cv::countNonZero(square); -// if (nZ > (swidth * swidth) / 2) -// _bits.at(y, x) = 1; -// } -// } -// // now, get the 64bits ids - -// int nr = 0; -// do -// { -// ids.push_back(touulong(_bits)); -// _bits = rotate(_bits); -// nr++; -// } while (nr < 4); -// return true; -// } - - // convert matrix of (0,1)s in a 64 bit value - uint64_t DictionaryBased::touulong(const cv::Mat& code) - { - std::bitset<64> bits; - int bidx = 0; - for (int y = code.rows - 1; y >= 0; y--) - for (int x = code.cols - 1; x >= 0; x--) - bits[bidx++] = code.at(y, x); - return bits.to_ullong(); - } - cv::Mat DictionaryBased::rotate(const cv::Mat& in) - { - cv::Mat out; - in.copyTo(out); - for (int i = 0; i < in.rows; i++) - { - for (int j = 0; j < in.cols; j++) - { - out.at(i, j) = in.at(in.cols - j - 1, i); - } - } - return out; - } -} diff --git a/src/aruco/markerlabelers/dictionary_based.h b/src/aruco/markerlabelers/dictionary_based.h deleted file mode 100644 index 8da43b2..0000000 --- a/src/aruco/markerlabelers/dictionary_based.h +++ /dev/null @@ -1,69 +0,0 @@ -/** -Copyright 2017 Rafael Muñoz Salinas. All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are -permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, this list of - conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, this list - of conditions and the following disclaimer in the documentation and/or other materials - provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those of the -authors and should not be interpreted as representing official policies, either expressed -or implied, of Rafael Muñoz Salinas. -*/ - -#ifndef ArucoDictionaryBasedMarkerDetector_H -#define ArucoDictionaryBasedMarkerDetector_H - -#include "../dictionary.h" -#include "../markerlabeler.h" - -#include -namespace aruco -{ - /**Labeler using a dictionary - */ - class DictionaryBased : public MarkerLabeler - { - public: - virtual ~DictionaryBased() - { - } - // first, dictionary, second the maximum correction rate [0,1]. If 0,no correction, if 1, maximum allowed - // correction - void setParams(const Dictionary& dic, float max_correction_rate); - - // main virtual class to o detection - bool detect(const cv::Mat& in, int& marker_id, int& nRotations,std::string &additionalInfo); - // returns the dictionary name - std::string getName() const; - - int getNSubdivisions()const{return _nsubdivisions;}// - - private: - bool getInnerCode(const cv::Mat& thres_img, int total_nbits, std::vector& ids); - cv::Mat rotate(const cv::Mat& in); - uint64_t touulong(const cv::Mat& code); - std::vector vdic; - void toMat(uint64_t code, int nbits_sq, cv::Mat& out); - int _nsubdivisions=0; - float _max_correction_rate; - std::string dicttypename; - std::map> nbits_dict; - }; -} -#endif diff --git a/src/aruco/markerlabelers/svmmarkers.cpp b/src/aruco/markerlabelers/svmmarkers.cpp deleted file mode 100755 index a00563c..0000000 --- a/src/aruco/markerlabelers/svmmarkers.cpp +++ /dev/null @@ -1,179 +0,0 @@ -/** -Copyright 2017 Rafael Muñoz Salinas. All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are -permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, this list of - conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, this list - of conditions and the following disclaimer in the documentation and/or other materials - provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those of the -authors and should not be interpreted as representing official policies, either expressed -or implied, of Rafael Muñoz Salinas. -*/ - -#include "svmmarkers.h" -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -using namespace std; - -namespace aruco { -namespace impl{ -class SVMMarkers { - float _minFeatureValue, _maxFeatureValue; // image range for svm classification - int _patchSize, _dictSize; // marker pathSize (total features = pathSize^2) and dictionary size (number of markers) - bool _rotateMarkers; // interchange rotation 1 and 3 ?? -#if CV_MAJOR_VERSION >= 3 - cv::Ptr _model; -#else - cv::Ptr _model ; -#endif -public: - SVMMarkers(){ - // static variables from SVMMarkers. Need to be here to avoid linking errors - _minFeatureValue = -1; - _maxFeatureValue = 1; - _patchSize = 10; - _dictSize = -1; - _rotateMarkers = true; - - } - - - int getBestInputSize(){return _patchSize;} - bool load(string path) { - if (path.empty())return false; - - -#if CV_MAJOR_VERSION >= 3 - _model= cv::ml::StatModel::load(path); - _patchSize=sqrt(_model->getSupportVectors().size().width); - -#else - _model=new CvSVM; - _model->load(path.c_str()); - _patchSize=sqrt(_model->get_var_count()); - -#endif - //read in the file the number of classes - ifstream svmfile(path.c_str()); - if (!svmfile)return false; - _dictSize=-1; - while(!svmfile.eof()){ - std::string str; - std::getline(svmfile,str); - if (str.find("class_count:")!=std::string::npos){ - stringstream sstr;sstr<>cc>>nclasses; - _dictSize=(nclasses-1)/4; - } - } - if (_dictSize==-1)return false; - - return true; - } - - - - - - - /** - */ - bool detect(const cv::Mat &in, int &mid,int &nRotations) { - - - // convert to gray - assert(in.rows == in.cols); - cv::Mat grey; - if (in.type() == CV_8UC1) - grey = in; - else - cv::cvtColor(in, grey, CV_BGR2GRAY); - - // resize to svm path size - cv::Mat greyResized; - if(grey.cols != _patchSize) - cv::resize(grey, greyResized, cv::Size(_patchSize, _patchSize) ); - else - greyResized = grey; - - // normalize image range - cv::Mat greyResizedNormalized; - cv::normalize(greyResized, greyResizedNormalized, _minFeatureValue, _maxFeatureValue, cv::NORM_MINMAX, CV_32FC1); - - // rearrange data in a row - cv::Mat dataRow; - dataRow = greyResizedNormalized.reshape(1,1); - - // predict id with svm -#if CV_VERSION_MAJOR >= 3 - int predict_id = (int)_model->predict(dataRow); -#else - int predict_id = (int)_model->predict(dataRow, true); -#endif - - // get rotation of marker - nRotations = predict_id%4; - // if _rotateMarkers, interchange rotation 1 and 3 - if(_rotateMarkers) - if(nRotations==1 || nRotations==3) nRotations = nRotations==1?3:1; - - // if dictSize is known (dictSize!=-1), and the marker id is equal to the number of markers * 4 - // then it is the invalid marker class - if(_dictSize!=-1 && predict_id==_dictSize*4) return false; - // else, divide by 4 to obtain the final marker id - mid= predict_id/4; - return true; - - } - -}; - -} -SVMMarkers::SVMMarkers(){ - _impl=new impl::SVMMarkers; -} - -bool SVMMarkers::load(string path) { - return _impl->load(path); -} - -/** - * Detect marker in a canonical image. - * Return marker id in 0 rotation, or -1 if not found - * Assign the detected rotation of the marker to nRotation - */ -bool SVMMarkers::detect(const cv::Mat &in, int &marker_id, int &nRotations, string &additionalInfo) { - bool res=_impl->detect(in,marker_id,nRotations); - if (res) additionalInfo="SVM"; - return res; -} -int SVMMarkers::getBestInputSize(){return _impl->getBestInputSize();} - -} diff --git a/src/aruco/markerlabelers/svmmarkers.h b/src/aruco/markerlabelers/svmmarkers.h deleted file mode 100755 index a08cfc5..0000000 --- a/src/aruco/markerlabelers/svmmarkers.h +++ /dev/null @@ -1,73 +0,0 @@ -/** -Copyright 2017 Rafael Muñoz Salinas. All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are -permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, this list of - conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, this list - of conditions and the following disclaimer in the documentation and/or other materials - provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''AS IS'' AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Rafael Muñoz Salinas OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those of the -authors and should not be interpreted as representing official policies, either expressed -or implied, of Rafael Muñoz Salinas. -*/ - -#ifndef SVMMARKERS_H -#define SVMMARKERS_H - -#include "../markerlabeler.h" - - -namespace aruco { - - -/** - * SVM Marker Detector Class - * - * - */ -namespace impl{ - class SVMMarkers; -} - -class SVMMarkers: public MarkerLabeler { - impl::SVMMarkers *_impl; - public: - - SVMMarkers(); - virtual ~SVMMarkers(){} - /** - * @brief getName - * @return - */ - std::string getName()const{return "SVM";} - - //loads the svm file that detects the markers - bool load(std::string path="") ; - /** - * Detect marker in a canonical image. - * Return marker id in 0 rotation, or -1 if not found - * Assign the detected rotation of the marker to nRotation - */ - bool detect(const cv::Mat &in, int & marker_id,int &nRotations,std::string &additionalInfo) ; - int getBestInputSize(); -}; - -} - - -#endif // SVMMARKERS_H diff --git a/src/aruco/picoflann.h b/src/aruco/picoflann.h index ea0ca96..59e9e2a 100644 --- a/src/aruco/picoflann.h +++ b/src/aruco/picoflann.h @@ -1,21 +1,3 @@ -/** -* This file is part of UCOSLAM -* -* Copyright (C) 2018 Rafael Munoz Salinas (University of Cordoba) -* -* UCOSLAM is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* UCOSLAM is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with UCOSLAM. If not, see gnu.org/licenses/>. -*/ #ifndef PicoFlann_H #define PicoFlann_H #include @@ -25,7 +7,6 @@ #include #include #include -#include namespace picoflann { @@ -126,8 +107,8 @@ void example2(){ */ struct L2{ - template - double compute_distance( const ElementType &elema,const ElementType &elemb,const Adapter & adapter,int ndims ,double worstDist)const + template + double compute_distance( const ElementType &elema,const ElementType2 &elemb,const Adapter & adapter,int ndims ,double worstDist)const { //compute dist double sqd=0; @@ -196,8 +177,6 @@ class KdTreeIndex{ - //computes a hash number from the index - uint64_t getHash()const; private: struct Node{ @@ -216,17 +195,13 @@ class KdTreeIndex{ typedef std::vector > BoundingBox; struct Index:public std::vector{ - Index(int Dims){ - dims=Dims; - rootBBox.resize(dims); - } BoundingBox rootBBox; int dims=0; int nValues=0;//number of elements of the set when call to build inline void toStream(std::ostream &str)const; inline void fromStream(std::istream &str); }; - Index _index=Index(DIMS); + Index _index; DistanceType _distance; Adapter adapter; //next are only used during build @@ -334,7 +309,7 @@ class KdTreeIndex{ left_bbox[currNode.col_index].second = currNode.div_val; divideTree( index,leftNode ,startIndex,startIndex+split_index,left_bbox,container); left_bbox[currNode.col_index].second = currNode.div_val; - //assert(left_bbox[currNode.col_index].second <=currNode.div_val); + assert(left_bbox[currNode.col_index].second <=currNode.div_val); BoundingBox right_bbox(bbox); right_bbox[currNode.col_index].first = currNode.div_val; divideTree(index,rightNode,startIndex+split_index,endIndex,right_bbox,container); @@ -632,14 +607,10 @@ void KdTreeIndex::Index::toStream(std::ostream &str) { str.write((char*)&dims,sizeof(dims)); + str.write((char*)&rootBBox[0],sizeof(rootBBox[0])*dims); str.write((char*)&nValues,sizeof(nValues)); - - uint64_t s=rootBBox.size(); - str.write((char*)&s,sizeof(s)); - str.write((char*)&rootBBox[0],sizeof(rootBBox[0])*rootBBox.size()); - - s=std::vector::size(); + uint64_t s=std::vector::size(); str.write((char*)&s,sizeof(s)); for(size_t i=0;i::size();i++) std::vector::at(i).toStream(str); } @@ -647,15 +618,12 @@ void KdTreeIndex::Index::toStream(std::ostream &str) template void KdTreeIndex::Index::fromStream(std::istream &str){ str.read((char*)&dims,sizeof(dims)); + rootBBox.resize(dims); + str.read((char*)&rootBBox[0],sizeof(rootBBox[0])*dims); str.read((char*)&nValues,sizeof(nValues)); - uint64_t s;; - - str.read((char*)&s,sizeof(s)); - rootBBox.resize(s); - str.read((char*)&rootBBox[0],sizeof(rootBBox[0])*rootBBox.size()); - + uint64_t s;; str.read((char*)&s,sizeof(s)); std::vector::resize(s); for(size_t i=0;i::size();i++) std::vector::at(i).fromStream(str); @@ -673,36 +641,6 @@ template void KdTreeIndex::fromStream(std::istream &str){ _index.fromStream(str); } - -template -uint64_t KdTreeIndex:: getHash()const{ - - auto toUint64=[](double val){ - uint64_t *ui=(uint64_t *)&val; - return *ui; - }; - uint64_t seed=_index.dims; - seed ^= _index.nValues+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - for(size_t i=0;i<_index.rootBBox.size();i++){ - seed ^= toUint64(_index.rootBBox[i].first) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= toUint64(_index.rootBBox[i].second)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - } - for(size_t i=0;i<_index.size();i++){ - const auto &node=_index.at(i); - seed ^= toUint64(node.div_val)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= node.col_index+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= toUint64(node.divhigh)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= toUint64(node.divlow)+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= node._ileft+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= node._iright+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - for(auto v:node.idx) - seed ^= v+ 0x9e3779b9 + (seed << 6) + (seed >> 2); - } - - - return seed; -} - } #endif diff --git a/src/aruco/posetracker.cpp b/src/aruco/posetracker.cpp index c23adb9..cdb7711 100644 --- a/src/aruco/posetracker.cpp +++ b/src/aruco/posetracker.cpp @@ -357,11 +357,6 @@ inline double getHubberMonoWeight(double SqErr,double Information){ auto solutions = solvePnP_(Marker::get3DPoints(_msize), m, _cam_params.CameraMatrix, _cam_params.Distorsion); double errorRatio = solutions[1].second / solutions[0].second; if (errorRatio < minerrorRatio) - return false; // is te error ratio big enough -// cv::solvePnP(Marker::get3DPoints(_msize), m, _cam_params.CameraMatrix, _cam_params.Distorsion, rv, tv); - //__aruco_solve_pnp(Marker::get3DPoints(_msize), m, _cam_params.CameraMatrix, _cam_params.Distorsion, _rvec, _tvec); -// rv.convertTo(_rvec, CV_32F); -// tv.convertTo(_tvec, CV_32F); aruco_private::impl__aruco_getRTfromMatrix44(solutions[0].first, _rvec, _tvec); } else diff --git a/src/aruco/timers.h b/src/aruco/timers.h index 45d7986..aa50eb5 100644 --- a/src/aruco/timers.h +++ b/src/aruco/timers.h @@ -34,6 +34,7 @@ or implied, of Rafael Muñoz Salinas. #include #include #include +#include "aruco_export.h" namespace aruco{ //timer @@ -182,6 +183,26 @@ struct ARUCO_EXPORT Timer{ } }; +inline std::string __pf_aruco_methodName( std::string prettyFunction) +{ + std::string res; + res.reserve(prettyFunction.size()); + bool spaceFound=false; + for(auto c:prettyFunction){ + if(c==' ' && !spaceFound)spaceFound=true; + else if(c!='(' && spaceFound) res.push_back(c); + else if (c=='(' &&spaceFound) break; + } + return res; +} +#ifdef USE_TIMERS + +#define __ARUCO_ADDTIMER__ ScopedTimerEvents XTIMER_X(__pf_aruco_methodName(__PRETTY_FUNCTION__)); +#define __ARUCO_TIMER_EVENT__(Y) XTIMER_X.add(Y); +#else +#define __ARUCO_ADDTIMER__ +#define __ARUCO_TIMER_EVENT__(Y) +#endif } From 9095d2a77549c39a2c7c929e745da174386a97bf Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Sun, 26 May 2019 01:25:09 +0200 Subject: [PATCH 07/22] bugfixes --- LICENSE | 1 - example/example.py | 7 +++++-- example/fractal.py | 7 +++++-- setup.py | 4 ++-- 4 files changed, 12 insertions(+), 7 deletions(-) diff --git a/LICENSE b/LICENSE index c0db278..affe435 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,3 @@ - Copyright 2011 Rafael Muñoz Salinas. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are diff --git a/example/example.py b/example/example.py index c4bbb68..6689498 100644 --- a/example/example.py +++ b/example/example.py @@ -55,8 +55,11 @@ cv2.LINE_AA) # show frame - cv2.imshow("frame", frame) - cv2.waitKey(100) + if 'DISPLAY' in os.environ.keys(): + cv2.imshow("frame", frame) + cv2.waitKey(10) + else: + print("No display!") # read next frame ret, frame = cap.read() diff --git a/example/fractal.py b/example/fractal.py index ee47988..4808344 100644 --- a/example/fractal.py +++ b/example/fractal.py @@ -30,5 +30,8 @@ detector.draw2d(frame) # show frame - cv2.imshow("frame", frame) - cv2.waitKey(0) + if 'DISPLAY' in os.environ.keys(): + cv2.imshow("frame", frame) + cv2.waitKey(0) + else: + print("No display!") diff --git a/setup.py b/setup.py index 56c30e1..dcb3027 100644 --- a/setup.py +++ b/setup.py @@ -12,9 +12,9 @@ else: shutil.copy("./py3/aruco.py", ".") -with open("README.md", "r") as fh: +with open("README.md", "r", encoding="utf-8") as fh: long_description = fh.read() -with open("LICENSE", "r") as fh: +with open("LICENSE", "r", encoding="utf-8") as fh: license = fh.read() sourcefiles = ['aruco_wrap.cxx'] From f1b5362bd474b74641ca03bb162418ee5152e522 Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Wed, 29 May 2019 15:28:49 +0200 Subject: [PATCH 08/22] bugfixes for OpenCV4 --- Dockerfile | 38 ++++++++++++++++++++++++++++++++++++++ setup.py | 2 +- 2 files changed, 39 insertions(+), 1 deletion(-) create mode 100644 Dockerfile diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..9cf45e6 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,38 @@ +# Dockerfile to run and test compilation and installation +FROM ubuntu:18.04 +SHELL ["/bin/bash", "-c"] + +# Replace 1000 with your user / group id +RUN apt-get update && apt-get install -y sudo apt-utils + +# install tools and libs +RUN apt-get update \ +&& apt-get install -y git-core bash-completion \ +wget build-essential cmake pkg-config libjpeg8-dev libtiff5-dev libpng-dev libavcodec-dev libavformat-dev libswscale-dev libv4l-dev \ +libxvidcore-dev libx264-dev libgtk-3-dev libatlas-base-dev gfortran \ +python2.7-dev python3-dev python-pip python3-pip swig unzip python3-numpy libeigen3-dev +RUN pip3 install --upgrade pip setuptools wheel cython numpy + +# install opencv and aruco +RUN mkdir -p /home/user/src \ +&& cd /home/user/src/ && wget -q -O opencv.zip https://github.com/opencv/opencv/archive/3.4.5.zip && ls -l && unzip opencv.zip \ +&& cd opencv-3.4.5 && mkdir build && cd build && cmake -D CMAKE_BUILD_TYPE=RELEASE -DCMAKE_CXX_STANDARD=11 -DENABLE_PRECOMPILED_HEADERS=OFF .. \ +&& make -j6 \ +&& make install \ +&& cd /home/user/src/ + +#RUN mkdir -p /home/user/src/python-aruco +COPY . /home/user/src/python-aruco +RUN cd /home/user/src/ \ +&& ls -lr /usr/local/include/ \ +#&& git clone --single-branch --branch aruco-3.1.2 https://github.com/fehlfarbe/python-aruco.git \ +&& cd python-aruco \ +&& ls -lr \ +&& ./swigbuild.sh python3 \ +&& ldconfig \ +&& ls -l *.so \ +&& python3 setup.py sdist bdist_wheel \ +&& pip3 install dist/aruco-3.1.2.0-cp36-cp36m-linux_x86_64.whl \ +&& python3 -c "import aruco; print(aruco)" \ +&& python3 ./example/fractal.py \ +&& echo "SUCCESS!" diff --git a/setup.py b/setup.py index dcb3027..a31d421 100644 --- a/setup.py +++ b/setup.py @@ -31,7 +31,7 @@ sources=sourcefiles, language="c++", extra_compile_args=extra_cpp_args, - include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "src/"], + include_dirs=["/usr/local/include/opencv4/", "/usr/local/include/opencv2", "/usr/include/eigen3/", "src/"], libraries=["opencv_core", "opencv_imgproc", "opencv_calib3d", "opencv_highgui", "opencv_ml"], library_dirs=["/usr/local/lib"]) From 294cb48e04a986310ea69aa3711c06a9aa52b85a Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Mon, 24 Jun 2019 23:27:47 +0200 Subject: [PATCH 09/22] bugfix for setup.py added fractal marker example image --- example/fractal_test01.jpg | Bin 0 -> 82846 bytes setup.py | 6 ++---- 2 files changed, 2 insertions(+), 4 deletions(-) create mode 100644 example/fractal_test01.jpg diff --git a/example/fractal_test01.jpg b/example/fractal_test01.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a78f77a57d18f6d74d571096bf28571ade836368 GIT binary patch literal 82846 zcmbTddpMJQ96x^Vzz{=L4Kv4wO(loL9LCh+nB#PMJRS*8OeGp(9@(tpT0?l!(yVL_ ziRx*Jq^KB`(YFyH>u%Q3L>TB9q7C#= zC?hi~3nP;qrYID~0lUN628Y8LS~wE$wk}q7INSdY0#a2~Ro|qJ)X+fM8l#MD|F@T) zjexcaq)`cgfJ^|eHVC2(`uQ3#1OSkd;%xsr;s0v^fgw;OWtfVp+9t&YHCg}|1c88| z5G5rjRIzo2;&%Y5t+d(L#$8z__$bUI5n)Tuy{%%p=V8+pQujAAyU5d7s%l%eA$9eB zF}J{AEpfZ;9q^7$dw=!t^z!!c4cUL-;Gx66g+@jHc`PQD97jn?PC1jBMrE8kf8pY# z%gk$e`2~MpFTBCIQ^FUNmX%lB{pXRe=JAu-x~DH+y>4z1wYI$xOM2e-e(3wy|9NC| z?8~@xLN+-!zaU>+TK@iH<-fQN=g+O8d#RUSNQG6lVP$gp< z<<0KFu%n4OCbo1H#Gc&S51Uj??MUCYM4s+e+iHgU{L9>bq5aRu{{ID*^?wxE{}b5% z8&^M|4go1{9z+{(1127JLYPGC$B}D~EMI0&yE1*lRu=gdY^=RCPd+A2lI_doSbJ-cYY{1pO87^QY;HUkGq1{Ws0(_h$=oB?r`^y-Jj$VowpC8IQ(C4aDUH} zdE-||(^LKsd8Oxxux~KgzE%SpZ_uYaIwyr9IwGd?p$~yXdOyAMGZBcXCQ}ygjG_v6 zsG72CoE}KWk91Tf=5;>AoRCre=I4;c@C%y|jeLD7psz2nhCFpeB7k#vFj-qQ6%~}nDQl7knh3$vs z1r{tjYj>fAl538ov{R1L%-{*f60|S^exnqCg^|A5w94GWG{1N&egRa6=YE7VA={?> zXEHE5K*NSr+dv;3OIL^>vc@gn-EFyvvFQJh=Q@B_f z11e=YHXAgw8>qUuQ5_m<(e^n8Qxn_yQw2m`)dQ zuB?|1YQ>AhMaXy~(0B34VU)UfxBv-|kmu&9oCByNJ}O1G#0;$otFcBar$^qVo$3*s z_OWD^NDMM>1%L=~8g5q0o2k!XpS?BU7t#6845PfA0CKuiV2wB{EQ5StMvPxa0CkQ_ zC7fh)f-)8WC$^O!Con7B*;N3>2p&7k#R38d>sX;iOGZU%C-^#<;N6VmK}A(o1P@GO zqYKAb3^cZAe)f5Ss}s1WkJI!A^StBsvQo-dm)ZdqP`_BuAsEl#_EG@#(p|kwt^2;?TnB5*M-dw6`*&pHUR#Z`^_b zX0Wx6V-(`3uAsxiT5CgCJCaue5g2K)<~*HK1fnurIw!*1&B-Z-Y3I{8?G5CL+-~7= zi}XUW91%l>JRqC8S5h__Kp?|U2gX4yJ_v9$@*w9ZtO4@Sa~XWtuCv4K*5MP;%*xDH zL{Hc6mC?y*l0s zfSHyNHC*QLxM7APj&_>b6_6@IsE`pEj)Eo`5%yx97XiB;nt-2lvjm1Az1gRHBa!+R zP`$9c#x*m;b!Ai&( zpmx?PY&;7u%bg~k(``wl`w~k>Ex6b~DqzP1fv;C|#*t;jFu&8@<9Sdx|vOC`fZ&-kAH=YWB#Wvlx)=Qh}z+S|UaH-!gn{w$N8k{f14=(DKX@Nuw zd|*X#iQvOa(PG^P=c{7~6OJN3@z##h%8A5#SO{{IbF?$q9WPta+XSSK)3n$=F4>9h zQ;mjK)dN&u*}&RZLGy9Fyh5y{BG zZzO$%qySFY0?cd+)*-=t$`=D5r-pJyU6OfhZv#T?1b)1r(eArghhq!3#*(ce3||2D zZ~x8Se0wbD(dW1SK0KcC1oA~~s(yWNVdYpu+hJ>H((Z*%^#wN$Co-DTpI@acwd;w8 zwf1?|xqfe2_rPx7qVYA{6eqS#3^d7Mbjr(jBSvzfdULuL?*hvu{j6l3oZq6HGpy#w zD-KmXrg`O*fAwV($c4glh5=>r`#W-G;|s^@1JOg7{H7C{D(AC%egcc<6D{y~>6Tz) zmZL%KatU;?dDpkabuvgKzL!HtNGByZmSt{3-@-Jl1OX~*6{>i0AyErYt=b-8Pvo5#Nc6(BYB+T2j*p`y$7QO-?lf_0lwt{ve%p z&9D1WjwJj9)BqdyTK51~2soTs;=${1z-RV)tSKupKY}`*6XodA1&&xQ1F_JUVKg2s zS87uX{H=B`<595e(!m}bM(y9DL)T=FLwzZ0&Y7-mRfiuCcitx2`m*hYXgf}t>Oy0B znTZEU?w>EhxcMhV2%w9<8qz3gfIzAR53t6H|^88eMyJ_xiElPyEp+cD1c#aBT zg)~MzivYD7;dx3eX-IzKY%e==eSb+F{lgGV-=}L;Tyz0x7^*h!GeuNor}52F1f7Or zRtgUY(zkfX7a`7RQF>{H&**+_oi$if)FOX}4G|XL-ERJMX(TIssq|W6GXOKZYE1ZE z%INU7^3g3db`I_vXQ5&cQK&P#$Yl9Ai{joof#>Zuf)|a@I|*2_CaMceVdP-T9NV#D zl-}%kVPkySikK=F;0dQO!*C49iQ@Bbjq?+~kU(Feu{npDT!v=gBt*onxyQDY3AObMFh@B4+1qc}sMl*5^gXBkv z^ZLYc+{K>LWZFeWFFS+m)d0)BFE9qJHpD_CE~KKlqR2e_nsbm%$^u6fId&Geb^bd}fH81XzFymcg~P(VY5?8V(JEs%hrqZnoz{|B!#L2@4!BLTxoR2ZUj&1Dt6b}x z^fA^s0l$p1cSv+^>-1II>*X8dh3Ajcvz$l~K(eD?c%=(WZ{IcQtvvbxcSgz#x95=C zns`dVD?xpDg9#L5%G(j8W(6wFmsY6}@hy~paq*5aj&u5o9^a@@7cZ?b76r@pWxp0j zz-@@CET;W%LL$*DeLR0Gv7d&dO#0)aF&4Td#eO6dT=??ksKvER%RNps&EA|kv40kmd#K7|2HQhfez#cw%Z*(#E=(goi|fN8VaVB`%b9EGlA@ zP+{v~q!t<=M=Q|GY_E_JUO&7^lE^Dm)#v5VH>OUzg?-3o*G#x++z0;~7Miy_s{Z^- z;7=g@;$4+`I|-}-0mp$}L z!p-n{vu{80%~jO1>5gQk(v2=jkIbt!Rh1 zfH5F&QS?t>rQA4mQ7{<*v>T(>m;edHM*?&0pvUY0Y$BK92PD8K9QRsoYT5exRwQp_ zMGOL3(ZZAXarS9K1rfTCN7R6nQpMAgK7y9R!-<|M!;7x@fJF3HB+d0kS(GVV0tYB7mwvtNHHSB>&J@J{N{eOe4lF5d&Ssx!KSEve z_UI7Rahm!9y_Huk3c#w$c{c5UeuC3koDzg3{@da{LT8q!oYBCWR-lX;#gAkX}^a5Sw=pqt*$~&VRbVHF*JI{JxCv7}o2w+gb z{7yTTfjVmlAJwjwz;KOMcml_1cjQlCN(}J^?(6a)u%YYMh&VBPMv=|UBCjz-Fy*Wa zC2KwEf~TkBl)Kr|NY1Jr(JF&V($d7C*f!p&(|%BsoT7DXUsGwWj04zB_2vvO3Gkg3 zOtQ4W2s7!j=Xrfo^I;bqQFz?*l43LT>iNLICn+I4fi4Y?-guXD{6)foUzG1&78Gr9)Zx5}}4j0hOzC~LZiQ9H&M| zvvo(SV2(}gc=e=q>*6=GZ4efR+^E}We(RboxvV&NmZ-|LyQb-DtL#2IbiG#bcwaQ3 ztG1B$Q6x;Yr73SOcQH+Cj7_#_x3VSpL$&aVO6o%H)V}OcY6B0M6!8d;SI%+(qzSP-@b|St{rk&H7NzC* z=2*1q4KtF;upXK5YX*#%F)=E>%8x1Mv28V7^V=XS652Vrq&G(ll!bUE?(#CxANe%!g$l<$$KiLurA_UkK|%#)t~s@?nrSbdBdWRo~W9AQy|y&<}Mscaw9h68=Ke#HB6?}_mKFL;+q z_}!s9&n_PM)>3l2Q5o#vcCB~=l=!k)I6KqHN_mL5VF^L8D2GQz61y+2NX~zK+ewW$J_9V3#SfpkN6)m- z4I+<{OtbPqg3kE-+mE=E-(HbI-ut^8d7apX0HvRKju`|s-pyLtx?vUPo~R9xf@wPp zZ+Id3!>E+YHpFyk7Pv`bf+6;lO4*as+6_SGA{;n;BOp18d!gd3#Ed=X2f*%V(m%I^b22Sbq?u; zy(Xjq6VfRos%;yW-WRyc6Ef8zq^{3}b1#1aSFP0}qS@&o5bkMg-%y%MNXlHZkxAW~ zw}>X6k45x}xIvv}%PjUiYSiwngKV#W{8y*+bNu3b7DIt zVm=*a21Bgu2mJ`HfBghpx|DB(r=mjkNbiFmHPs&+`I2p*yZC*qsMC(^qRa1gFO14}FH4Dq&^@;$@>FShc*I^6syjtcIU6B7s*2^`34 z*iW@Mh)7Z26Y%XuW-+*DqtD4sn>BI3?b_Ry2oA`U53GSfg)Vg0#A8#D2J6UdGrAn1JjQMfr2~_nYyq>apx)` ziAE`9T6Ur-e;gqBz&u)^NM?f5DhPm)JH7AxK+%HCZxf?vE&w^j>H_QeKa;vpNjcW3 zJPc2n-dSUeiVo=@U^Pu4Re)XjlsIQDfRE>?IkC^a`8RlNGC>7c2#Rx?oA{`!YuHg{ zn4~^OC#o`9$C!HvSMhUP;k(Cy0su)!h+T_yhyzZ<998**+yc}gGvGzo)v<3jQ2RU}xRJ+Mo$T*CE0h&zdKDo6JG1t4F zd@(nV3BVos9kwcb0%lBsCE=;~HL|8cJ^B$qhI@%=U{5=`f2(OV2CChTl_O|mh*6LN zgZay*oIPIgSOySa(-CXRCfj*_~)0u^79&-x2bxRkxkk=ZV|3kKIypU zbl+%y|ADW6&p*~?#r%z2kDI>tkGodQ^SxglG#;BKH5)Gd)#C7@>dUZ0Sa70_-~9GX z^)a@_hPKJAD=DQX{9ms0#k;j|OJ0lyJvwDBbT$u04n=eR)&AW*k zph;66%;$`Uvp(7LWcPNMYtjD0J%OR&Jrrh0(Gnj*5&4FA#rK?4NM=e2NZdL2`(yg2 zY_4R%~@v&Qt zDavQ3&4C#Y^BH-4`3V4Uax7C$Y^D5=P}+6x47>PaCZr2xS1Rdi(LE??aI^K!O+Ol? zMd=|e0wYIDoBgZFB^JE}jn8+xehDB?RhUL=c^n&C4gRiXrTovN7WZ7XpQQQguk)k3 znTawl^o2tGsYHFqLUu=y*+EgesJCv0;P0HC04Y)fCftE&!;Y**E_JCobsxrUJ14Wh z8dx10p*gfIkEIA&32>#On^tLQ(kYTvh0!FfOSvO}Ao~c!Fx&JV%v{`J^xh=Gu2vyU zls$`xV2QKvj?$q=EhQjR3&Zo?yNnZG-=Xcy;wO(60l}|O2NH2798QINm%L?kWj9K| zeq&Nj!co~ZOKYMj=Z{xKB+wW3=`_Ix3KBdEsI#%|jv^{>CP4Ug(GmA9$16;7McQ8o z@0I7XaL`RXJu)oGMgVNMjGm5k6fY&ScfqTNOl z32D4*&f|sf;aslp9FWLj2Gxem@cRdzCQf+++AXg6eDs={W?Tzwc7FC#VR?Ui7klp%84dBW4yuzQLUykQS{Y9nCH zx45aVW^TQFG_`zyV*C?GQ-GIm0}@)Hn-d>_7%Ic${O#qqzZqW?%< z634#EiNGKEJ$J!**ZaenzNt?i$LE!eyx%G*iU#=tP$}$*FY&iSKCYvcnNKMJmW1tu zs;ahel{SKpd+?S0dsiRlW`0UJGDXx&S9LpY-c-c(k2!xs|H_T0F-r7}h#vZk&1=yH zl=l-j4}@Wq@y*s)sl?^LDW@qH7eBZDJug~0fse!P4`tb-D~%1`1t~QYk+w9p-JLpX z^KNri`d?)VlC}2Rm*^wQIbG0tIF$rq_&YrA8z;V)1;6Mhx~}D&%CUESr(vyC(Wz^a zGlurq_oUV=JC2M1>7IalI3&s|R9bv^)t>lfBU6ihj!%cBe_4Z)LZb94qKd~xrvkQf z{kZN?h}4B)9dXPcLp+1ycQ3@^%0>*UQNa&85jp z?d^X8p%J7WuNAXm_qFE0UYiy;Y`*+d-J=}Mz$wzM72(+W`;Gmy6z?NJ1ajF<3DA|` zl+1Sog1}0PxQldpyBk{0IMqwj0kErBLQUIFr$@)m!g*v7EAS*q=6zae7p~Bpwyj)>kTfmvSYTBi zh#d=pIgZd9#}*f--SJ2RGOS{p2ATC%nWS*@%RT@h0Tea{L~I%>3JDx)6j%)95!h~) z&{uilyrKnW7#n6-VD4I23PvTh!|4A#-ce6*$y0LvRvpv(xLXTTzMxJ64QM1y>og@- zB*3nS0R_R+M5yoih=P+9?FT`Nr=7Q5m)_stZza2R^AZR2wnoVgo;cyZF8cdVwUTSj z9N9E(>bT9N?tS!Y?Qer%_PF|zlS}uq8ul=_t_4AMW(?pOb>-mX19&+svY_ zxg8U`cAWif+w3mI9m_x0a~obqG? ze1asfscJ!of;_VlzkIUzkIQaSSLUtVV(2IvYT7&(!8rRO5AX>Qh z`^_hHH*RHBds-_U>Z4pcO{OY1^n;sPAa;JCs5d{k1Xw5v(c0R9RT*K+6D2qtm{i=$ zzIY$O_*MZ*rwrvMm$K{H1j;n0Sx~rsruNHopN}16NoBb!%*8JjTZTEiKR5J%2G)Bd50&`a&C85^162m=Llbm42b~wRVi8i`!~$6mlKHq9Xf??HXlkn z=x3@>uF{aR9H1&Y)aIbN8Mo(x&NNX=+lN{F=9Hi0uO|lO;2k7w($^Dm9OBeoqSnZD zPFje}hY7@c^V?>ytC^PmLSS&@x(jK96$Cz(<4}bSweJFN6}0jPWS$rhMb2+VmZ0S` zV7Ul)WBE>wqQNlxcE02rVz65Q-bK_PqU#-2mu8hStt5K{cY6?x+DIDg&WWwveC2Y_ zoblSEM?>9_k=DDlh!?lEfhT%qwpD9>4%Dk>mv48Q@Q0YPm=VXVs-OL7Gu7@A*KISV zJ+obZzQnZ$)MZr$a(Q4FntO^DwJef`eL!Eh{sPJbCby1Qn88A1?LM{fQ;aZPq?04! zvrF4@wA(Ep`S%9QpcB_-sIK5yT{t_=qo+D(p7K2eA{Z(`EsYnM=^7{>zojSSeaY9m zvAgoJs9~t0*eeu!XMlUdt&h?p+VRr-FxW>AE}(uxCbv>L?yRec<4RGW25D zs-!n5{tQHpYy3w=(Y3zsyT_*$sy!P7L*=-y=$%#6V;^eykXQCjs3d`Afsq=k)fN~Q zkD*YE84Q>RGH6;X&HIqYIdy|Ui-m*6vItn(@W)}wwCC59(f&eTuJbDCg1)yo4XyvB zwH>-ve=(Hh;Mi(-9&;kE^NTkO+h)-tX={Nc%7S5yW(l$XUPE?4>yUhxF}9N383K7z zax>rtF|{bJ#s-L;z!`UKzfW`i=-ZfREd}RZXfqUG78RoJD}8Ur&Nv4xM^w_3H_UrL z^kCi6oN4bEeNc27`(w~k6H;Sr#)<$<5!LON-YFX&Fnv15IkGEOKRgI_aynb;MQ|d` zjEZUcm+hKg)6T+HNb&VVm0Q1mI1O2Q81RX0vqIW@cyWXVBJ{N!-1-xEetnI6_Pv9C z)${rzZtv8HX^OU64u$bO1mrqEf46z#;!4*p6AL9X!~M7ysc<-1Z3EJqqjqZNqj!_A z)g!wW%64?U82sDb@au!!+6UtAa3U_>EbNiig-O6|jm@Z-p}YErFaA2PA!|0GY1Z#h z!18l4C}9Iv5b~zjY|{;3xoIOZXQ#O6N`dKmxk%m&{0=eAW0KJgmXMuYlO`vqV7nC# znLGR~B1E3KQ3H7W1**w`7xJ$-?>C%btc3ijGkBGC1rfcl5Y2gDVhSVx%>WL?V%qkh zg(LNzFd*`~YZs~9r_?ojqAaZ@p2|L3#ec{pt1UioAu!eQ$0S44W z@3Y0X0HY2kj%J0R15U`8==VYeK?23BnErg0PM-e&TMm?!QEhUwDm<*4n^QyH7{4sbr31Wx22mF>h?fZJ#HHbN}nY>ko14BOyvB_yYDn8_Vl zNwxZG_^asq6O?o+NSiV3ttdD_U4wh!RVSBjp4f5M^-tI57b*@PArxIzfAiNr32(eC z;|c^le^YkkK2A9MCqbp^W}(UZoz3l!p$)o}&aN)-KK(xYQ=w&-!;X?tw^u)cEz@dW zJj5ry#kduUezfm@_#*w_d?_i)LcQ$n`wG)^Ri*b2KgIVcHpXnqHX(Q#GY<|G#$j1kyXHTVDiZd&`wtJa*zfCClTbX9H>D=M|4?)l^hT9LG zcv^H}>tjz%bm|UA@ZGmNo@}=B`}$gvNW%liID7OwN3XpuKAV4Hw92P(>{^^%)3CN5 zQfaZ|g^QZ%()5%M7vK?zT2+d0}VNDuQ=69ZePU@ zP&=M_Qs$X=R~)}))qjvY%6oh}!+D*v0|u-(8ou<{)4vaH{pwrwqHwObKKOBw&2pyi z!C#70C1y?XmHjdPc`oqn&rVv$%xvVpDz#X4^W6c1CjB5N;rd$LF4R93hnP)o(G`an zrd(0~?9XR>4@5}fMjb=`cuU?ypYMtBJ~GpN6y^5u-&Ouu#06yo_qEE$Cs7ff<4j9p zzAKv9hhw&lEjHqifr1p6hjeD6Kqt23AN6(2gTrI*4o~~fFZ4exxijkai)X*_*Zjj? zwvl`r^?7C2f^GxEPasJGXT5qTh-7EBEg>#w1%9d;<>SAmE|nVmvc!E+uvN$U8NImP z`{akA$2a%ogaq6)n!r4`7lnj17&E#!AM7`0e=gP6C9dWxvF<<09lE)c@-?k0glsff zdSmH~VPh=Bx^YyT^Kxx2)N`{_#ahMlV3Dbur~dEG7f;D*=;7Ytf-Gz71(!txyd_0t z%7>j+wF^s;m=s2k0wMFf9YM{=%9c+FsiilQml0~sE~Ln+n@9V^`cZvdTP;V}aZPl3 zV^eA2k!p;=r9_##Ip3ysL&x9JE7;@ZD|g(n>xd|h)m9xGL?KFhyw)vY`UNwsz;j*! z3J*(n`!-P8Vu?kcnBs+-0WAja6D9LIamTLEo>6l>=baq+%2^8F-mzew^5&JPL7aQq z=>{|N%4M0CZmCjpPyC^ZcHgJMlDmxG{=F<1JHyl1{eGRq|0C4IdOz!+y9MEe<=(s= zHQvKs~1n z*s<_b-~-OeTrrSr^t?7)(F{!beNHsx9-q2}wtGAM12n_Z{cfwWS{4Qp`{W7YcGkQ{ zv_@EB;bd^-uhiQJP^m!xXx2R*kKavk1X)vvgqv<=m*Z>{z2fihlb>FG zan&!OL2s@`B>EI-#_f4!3PZ%Z-r&Jv z=yYPME>th}#8?XA{KKM!bu4XN^u%{B_ZG!lpMA?I_=Tc^X%ZQY(E3L4C5fFic6gUX zKJ*+7%g=F|lX-qt_ znp?YA!b4i%woc%|IZJXL#4xPO9kt9;hdZTr1sY6%iln(BYKo1d!C0z`tEUbtEFdjj zh>J#1;OnuXp(*#(S1xpKs9Ji8pb^E*zgQXz+1X2jd{r`T8;i`(zWE%hHd;mn_P$&~ zoV%7f&gi1};(2@B;FuQb!oFUHD1_mcqQ%DZCmN%eM_%Tj#?YVEvA|yg^%QrbrL}Sk zT`4C%kmwI!m-wAsLEdXl$8yj%M3AG)Mg&Ql>(gwdG9?n=*s;JUzAQSb#sT&O5o3_u zOILFmW-E*W?mxQVnoq=eE^-_IIM2D8_K2@Jj@;}oR3WaBGcRPhPbT_!Lp$K9f>sOM z#av&fr13nYHa9(p!t~1_E()NaS(!I(D@fY zG9pVSvg|v#v@tW~$vX%a`y$4m8DRg_x2p^%Da-adw09|4&bJ?Z!1I&Bixd@(?Bm4t zJN6%^eU^f``5LH?lG@c50&AJb;!E|-uO$-Pg%3TE^rAXR#z9Wfp!7>MuOD7mdegX% zWcDTC=0B`5zU_;H_K%6uAU-hH$CJXKec`EiT3Bz2WBf2T2R zlx#)Fv}DPy!QW4uEY+MjTd+wMN68mNxXcNE9QsbaN;Yy!_`tKzDIP38;0U6GJC+uhmhUc)S}H}Zmv3QB`W>X74?KXl03{rxJ=}W|S$W|T`NBX~*VgUY z&Bj|I8i#r$kYxl&8Pn_=b+kX{b~`va^$vIcQVCg91K2WCBpkH`;#UXUv0G32^AIY& z;RGclzZpOxB1pMD;w!YM!EVNs2Vw@)`H&~=3igbxg{?umMYSckV}-y{B=&P(62-3_ zMFIyW{x5C!?fDJcxaTkdRFfL7y4Wf%zf!nhikH6vw7;N-nwDp z40*4$qbAWnJF)(L=q4Ifeh-9WloWRqS;d62Vj)R*3t(|-UxP>FrjHGZ!m*{qXt*2) zsy4Jh_rx#Demh=4^TA|7NE*JbpU(raGmVXi__fJPJw~D-qvGJeZQb_P^2W#drean? z+=DunJQ+7<8#N1I0{PscjimYqX|iBlP>V{tae^{TD)Uy|m)OXQP987$w~tFcGZv9t zYW(G4Bma}EsWg6Ce0BX1XD>Q&(ucoOVJoB8jmmk~KrLk2h=`zsRoF?g6Ll?e-6Q;s z48D_4QfLH88L`>93kc9-t1gyug$f}+O_9WjHXj;*F;X;I;p~9jZpO;iDjX8&Tn(68 z2$6wTIGlR3MD+f=F9u$?^FL%nka<2T2`#6M$=mhoM&gkfzm&qF|||BVfL*FBQ}Van_#WtxJCv|cS?z7iN3$HP#k~=S2ZAS zvQO_85j>1xc*jyOi_r{``ADjEg(&=BOT4bMc4Gt`z}2;)duVe^0@+&a(Vy6?Nylx* z1+O47X4StO>NO`4L}uI>8j3MEZkMnnPE2@rSia>j5ZDmgq{}uUq}^rem`@XV@)Fd6 zYYq*D9oOedbjuPp=OhaVWLuAI03nT!tGiRE0{h~>eJYSYtFR)n$!aT-Y=hWlBi#pj z{?B{nZDVDA$|sd`c+;dacW5Sk1WX^n(k}>B1^vf_@qlM!QaX}{0BN(RA%EQt38r&E zT0bIlS~LRLv3TB@?S<#jhj^6$DI&-Oq{6p3aP;bNl7j zl{jw2A7r7FSKeM+ql8LVB=WZ_2hNDKegaAq7xDs;TZ{xtk zsWQ!({hFl}lP?5YA)ST+xn7Xnx{q>_L&9k*B*V{lXZhIClUpGS`x(1@w*u>zUQs^| zC9L4(cRNcIov9r#Jw?7OeAIX7;0k8r%fSr&`)|mg_QFGkDL2P<-L8^~52NjVD30%~ zFn%iAJdvAoA_$kNjy=rv`cxkJUU6zbyLE0qC(5)YR=C57@gu|+eSv1TMDZrwFI@M) zy(VD5>^Js$wMS7SoTDpUCZ(@D`-MlBOMmzgCN^z(ps*6v9L9KklccP4*{TOK3(MQh z-;HPe2FEn-`?4DR5AESr#oFV%qs>a%3!WM-w-Gn}p?xP&l7~}1PdMP0$5>*;qZGD7 zmp8%+W}X3A6R-(bn|&UQHtezB&gH9!-~`Q^J%%syU|qrgwb>XOkQFhFpu!(#jTC;} zWpEh*PA3?-%InXA4H_0+Z3sWRyzOrHOk@UNz(AMmvp98Z#a&y|wtL~x$ zWmmo4`;*!_Lv1s%KNGhpnly+-Xh`$dnD5!*M*);KOl!CLl`dsoJ&P5O6l_yTRd;iG z)BpTja82U!rBdbET;k{RO7l*=M09q5lE`a47P8;k;(oZWzCq(pRr8JIseo-dnj|c! z>;=bRu4Oy!4{s+n_T|F+SjgU#08NB~R>kq^!_FXHkoPKV$ypiX({M|Wli^4ij6`{M zHc9F7nW)lKp2LZr-{}({1sXYyydC?VQ6qC6d;PVaC|OXrvz->04wT$>96CMd_cC9o zRfZ2D8Z95}ZklZeuy}=MjReVSEvYd-O_lQ^^E$(VxgSSspfUXn8esxNgos&iA%nYK z;Rve&kh)ERR*~=0nd2nhXFL zQ8hak1pnEJ0aUj;AFSuZ40WC(stz>lv?2?EGrWUdmy@?iaQZh3 zZ=R@CJD02;VE0|U_~o-tE~lzn(w?fj^?SI93tG~ZQ^&J?=WCxEPfmKupB$Yj-0-aS zm@}D996#Ln@64lJ-zC~Ih(SeW=x5{adGUPZ8nq(dqfgKUB@cAE#K;zZYuok* z@=|?wZb8)-c>XH`AnK;eQmMX;B(|yq?&V9Sp|f(3yQ1CdgKM&iKUa+c^3t1$G9qe0 zHY(A?~Bi`_qgkL#8~j>Da^1)m<@nhttg z-1({Vvu|U>`3MF9IwdjFEZTLIp^hHX7Uefx@GMAz#G4P(lwZCr^vc-KY^6W z=lOgTU9pdU494Yld3*i+18xOpPVuoDdetjl;TXte8|$wgIMMVUjESGXSIsw-u2(mj zfzvHEgCrz<`Vam8M)l}&MxP$gWCQQH;70v;5-ak(ER@0GfHyX|;=H$xve2DTMjLuZ zA16;}pG)vC-s5~=6q5ZJC()JT)CEFn&>;h*-#>DDBuF{WBj~yCyk$2F-Sh8u z4sefjmAiQS&2njB-3VKHsI3~G0w(w2vd805YtMi<2NfMkO!3rv9d0XpJAwruK+^a-|rVq@=lc)w$SzTA9Z!tOE`BN*x4)M z+59AP+O8OZ`RCc$W|9tmQp0&#V=zdm{iCCDP7%6bf7tNYIM-^M1Oak%oc$i0H<(=h z*Z01$BE5uyRA7#{IeGFwJ25o|*FG7DxJm1OJmTM?rV1*qJ12gk8d4hHo48nw&$w4INFgyhi`WY|l06bG91ckK}ZWju6# zevFu|m?;2CY*DCTT%q~~LMdDDG^E?X8q#2Wpnkvpm0a;7&v%cRTlTD|g~Fu!_UF)w zecd@Bt^7{vZEMG7oaCxvk{u9JV?gm5B_bMO4KOAK2c+=PS*-cgJ2}c&I5u{wm!?PQ zSGd$F6#lq7Obk$hqIiJm)`((XQY>!|smm#t2q3gQ6ls$`;;QI>bHb-#+%GgXnARX_X-E_Iq>FpKIqJui*!k_8W#N9Pn=9I=i-UzA}3#{~I9? zq3KRUbirGveVvBU!Y%?O5W-ftt^W`ikl%ctq4+!d=#04}(oWD(j(bHx6!SsW$!h2I@yz18u#70eubKx;vX6zuf zlCf6V(!1v(?8#K%Lcm_^z$_8{mJ?nx7BsmncKp#Y6b%POl387=3=kCE@JQFG$ z9}(|Uc5NlkoIPs09-32Mr6`2%9UaA& z;#`s{Q~CWE@QriS5I>0c{t1*AfdCbqY?}77eKJ@9aNV=w{P(VyiM;$Ob|?$J@^ zse)-Dayq8dJy_qGGT;00Vn64o!qtDSH_E`${9(x2?&l{(0_%ZnU&RaxZmr9H|FYFX zo+mF*L;N2Q$|0PSE(^_j`ZHHeo-&Rr{)DT@_>XUOVpkN~!O!|mwwKj-_C^_|&>Sr! zhgORPdsadXKX2*NH(u|*d@o;NP8}`w(Os?CL1kczY=FZvLN;Yz|N#(ZwDea@#x z*@83DfW^>DvNxFw`JKiDm~UdRfxUZw14#IKV^$VypMUXtrlM~EKJlmFtKgeHuy1;^ z@SKa^74pjmMc)AQO8*S3z^%YD(sAN=t&>~Lo)vrQE(O9JWzk!w{B2ebg|9fQ0vlT( zvD^v|+80)om=jrDAUyKxZk^b%l(-!**T{C<>*Gl>xN1wHynMhXQ6c^Vkw|tb-^S3l z&ncSW_Sw(r1Z}+^XtP1dOAE6FaW_>JG~7R*@g3P6VY~K^6T^M)#BuMBZR@Xog!otf z1QK6Z0-cz|E=kJjLHd)UZ3ovXTo?-D^MBIHmUM-+=~!N??pV-P%n0j%1iV5*ZWGfF zmwF&8JqJ%tco@bkwnH8UF>Ma|zo=WQP^w#8$3PGEV+Iat)Ki&(#tr4Qt!gWzEtTkf zDW!!sYjHC^@P9+?*;#`5!Aw=Y<I17M@SLGu(~Nkhz!r2Qshi%=2x^ zPVxs9?+lxd?t6OmPR`D4pnW^_FUI)=3s*uw0}t@Hc(Q}ZGHzyr!xD<{ZdJN^ev-yY8N|Nj5l#)ce{ zdFM2Th>gl=m9tS!bDBAoRH9@$kwg?5NiEGeT4I?w6;c$HA~{t~Bg!c`kBH16r@qh6 z@49~fIF;)%p0DS9-;dLMbg1Al`f)~2F>qQtmMWsPk za$|W`kn)W6HO?CO29A0oV2!L8(P7Afn7TvvQ_)n18^JbC`W6$6w2!qeKYC(YG1%=c zvo=JDY8FC~FDHn3LFfo&qi=xrRzSh^_y?R{hbZ&L>D82#Uq*tzYJbwvC!bt@-@AX0 zO>$r_^0!M>mB#MDhl~5O1?^OJ-^uqIN`e(oJr(?!;y@(KbA(t~lj!*%J?C*pfwcu^ zC`q_MXSU6GI}q^(kmzQ>xWy!@hv{TZFr0A^ZA#H)LYa!~blxJzAi+DWQO@4DJA-FPxfuoL_e+gS znRF{ZQ^FZ6@yKza4_o%w1Uew&uc%JQXqdSD><=(bi*={#9v?V6E6Q{ZCLNQuXPN<1x1hEDVQ zc6#;Bdl&1aQ-qF0P(9arvGzir5|lo0?)sKOV{42w*f*QeE20ATtJ+si{)0+9T^kRG z1}!+ftAc>AYWU{Gk42`&BWcP$1e28!s;Q#36h&`%v*2R%+o$FnZ%2<0Czry4UcFp6 zaV+I=P{_2HiS2-(!(#9P|&kN3vQC-{Tb0S{Zw=NBpFaLA zr9mF^wR!7SX~XD4Yt=86526P(e|(|)R(DHt8hjc?#dgPxc#%XBsW~)ce|B+k1w(5&z?T57SJ(^#|t*1F}!>o8{$Ld&IT1d#CH5G zmA-;nHd=f8!gtD1HqpGZ7J4CmE-i&_Ev!oAvw@Nk)TWlm$u< zzF&gasT|R>&9d6*_aNv+qnEG8<^UM1=;Oi>pueHh!5dJ}8Dqsd;i5u{Q6JKkp z=Ix7`z3Sf({Te5p4LA(Oo~iohUE=qWxo=zx%2p`x&fx#<3)VP{xz9FI=Dp&Vj)CDT zbshgdy<6M%saQZ06aq@2cH_xgqoA!>m9A?%tC&fs?>_?}bIpXQlfVAQGn5MAc>_0o zaPJDXn;FS&{VZ&|H3(<&_4C&yK4o4Rikix;3uzap*OwQzF-8I3z;^{y1N{^?ens#< z$w?dA;I6-};>p?tyc6^*tmqi#m2~qzZFgal8un>d^D#y)8`4uvcFuEAY4v$3TcT0u zBN9eN*WVA|yUr+YAx_-7a;1G>Q&T_p@s<)7d{=(w`s0nFTi@f|MtLW0_Gw06WgG3f z>g9oHH$Sjdv__WqF)9fwdA!eTs*n+*yJ9nLMa#myR7~qSk22}KIHaUBAiXU-+Pu!{ zX7H_n2(Em{%<;(Z>yvZLdlg8f4*|~lm95?K4o^ z$@=%Be?48{yOa-Gxu2l3p(tr{8BXxGAC(U3zrD(T+ZIa`6w}=EfT)h^V();cLG`6F zjXGdGshoWVEbu<5(?({d6_RPtI8jj(V9tSLSsh|%i0s0jpgDjP55@enKR8ga_`?%a zJwpyYO=LJ?iCvUe$6;C6Ms!3~M3P|E#tZhgMkFDlPK%Y?m{=6vH!YI9&V}Vywcidq zapK{n^YTc~y@_X(M$Wx3DBH8JIhj-XS9#pW>g30broV}wQg>%1BeE&Q`ovGp4!&vH z!SwCIw}9)#k4}PGO|%tUVQ}$(5XVH^c#O=DK;YT3z$ml>3Dp(&A@VIspL~c?sO<5n zy8p|*@~FGW%c1Y)+?V64H+-YJ2ivm0NWcF;EuS=wIIGHY9tFy-H+E5&0nyB|5x@S+ z(p!hW+RQ5!Klrx%o9}C$$r3+u`q^05qoCT@=%rTp{__h=_YaS%lqaYPtyGwg4J&Uk>O3O( z2mTLI?^8h+lW?bMM>ro1{aIf{F@}SQ$(XvZTZ*@s=u3NqM$0jQt_nAiGN__u7P9#t zbfC6Mb^R?#rg&f2>ComGr>nlTwA3tr=9m6ENwEwAAig`JwFv*thchKxh7L)tb=ALq zCUE^jzFwKR%IB-I4nnmpbpztY^vjK7RH25$(c#8LsASitx20WynjR9ew*KlH?cA6- zeJJG5LQ^Z3bE9)Ky)S|;`t*xCp`RdfS2;m9nJ&qQpi?gAXrB+|F+KX+6#f{wIeh#{ zOpP6)D!OIoU{~@iJ#$mv3}q-kLn)6YMjSpfVBrH_V!_gIt`$_nMoPhsP=QDU{hV0d z_Ao@7(L~m2K<&x&7Xvz;TXza;YobpIFs!iDx$00rUW zJA`A|Tj{c*=%TjHS>gl4Ti)7ak{JenTE3%6d# zZ@+YKGJni9k^5W`uPLL)Ff6pSx)|J50)@J)j=H-n3MoWBR%!;tIQsIF_0QNNldIlk ztG&`)DIt!RIq^WsHsx~N;+4VTuiefo3I`V(j@@ly8pGbq>i&ajWXzkHi+evNNF_53 z1Y&eR%2SWuLew2))GWPv>yOS>df?tj;zRlU+k9_`(xM-Q_bQ+MQ^EafAj^^nrH{zo z@=I5UeqQ%J-2_~-VpaELrj6I!Gb^>eq2|gilEgo2!8UlbIcOiYPpdJtL9Sa>tFX;x z{qVuXC%UVn#|hADAQ*_)Zw?^)ONdID)@#>KO71_szTj1*SXjGt&(n7`Lo>@Uzp?47 zy4IRB9yWC>pik?r^PK~Sqn1DXj2;ZVH2(y*AYmQ-_7(O;Vd!J+*BWFQKR&@CY_;v`<%H?B^&pSisqf( z4x%7*STnXH-@Fkzbn~OGt#7MSfGU?ZP&O{&tVJ)U*}qclqgK1sTg3M>D=SDIv~*Fk z?rZ}8NhTW&vuT#)*q)AL#~v=(Ssp4y3$NOpEt>aAD6`+M27=eThrl*Rkhy zxy%dk9Jrw$ht?157%39-v8$e*%cMxMyani0TQJH>Kb6w0uTZ0@o<0|La+&9Q^Rb9e zCX~Eu2T0yG>pV4W`Kq9e^|pu~=zX)AV|T0s`O|Wv8If2!`Pct#1OHL|oWv&%qe{}8>Q4}0odWSWOql7Bqj8u@_sYY zC0~S2S9r@|XW18y9Vj&_%9l|%y**lU->#QfE#@;{v$SlN-&T#5JGog%O=oQmOajD% zNz;%Kp-+Uwbs}6PjiYuIZ0kbP@mHz^!jwf9Ptfv-BJ{;`A@2RhAf&CzbgH4)wE`3_%_Yl) z0L$a7xvY{PLpB<21#n8t6nnKD}12o*!xz1xkLj2=LpD(Q% zKeHq{JZ;>s%miO3IChLiQwV&Y1TUc_mIy*@*;$Kac1H({?m*r`Uj{J?jrWvpk?K1V zzEbc{gzXmh3}3n&Qz}VNSR)}1zmw@4Z<~>!nGZH^Sr@eom#8dOs^9(xm20d{ymlZf zzV)XX3Y!R?7uFg2^6pFVkI&LhC!w~easGw&1r??4-f%-U;{(-%w;@ruE2%^@XMRt# zuDkpP=3D!JkmAGmV!f=W>N3){zg)jcnBONQ+jrF1-JGUs-7NQ`>}0q5*2mxalxlr@ zh78hm2=A;q?V&h|7imhgsII?&+SVf0ARsF~x3i~)!k;;~-t+9)iiLYl{hBM|{HW_z zo9ACSc+>r=>r|o1s)E@w7H>rvw`#Vp+S{w8*}0m=PX3)Jb{sBLNX2yD-TH$B!6AZv z@eYE%NE!O=qUIY}YYeUOj5;#*(+QPr?O$$2dySvI=l(hc&1Z>hc_+X#YA*&4alTDS zqZ4Q?t*CR7b*|Y4MZ$foth0{|Sjd-0uTF|}(S7c$?L327B%j}*tW1mTmOH1SdC*V* zDDL%rF4|}s@bk`CG;5fr8+ODH-vCjRZ?SCBSpz&w!S;!|wY~UPEu9mFs8t$6a>*@0wtsJk>8K#?xA$@&6&p<>pO6GM;PQ%-nX)ai z_$+$8psVDd!0F#DKrL@IKI{`)+b%5+)rK}N7uD;Zl|?f3-%KFpS;*~IsVGH0?Z)4t z%ZTl@%-hdUkI~{E&JT~#eOyy%^x(`bclQR_*Wm*&)xexxBAMrDg(`B z&UFUu$2qUp9$b{ZWszstR0D-dUMDQTgL-vs&HLh_^EEe4?pSiGz2Dc`ROkU*g^xW& zL3cAI3cR?Mi6b{zi3f?+OIo^0t%0AeJ69_IWnL+c{vK-n^Mt>+7=BWb51ZyK=-c`p z>>t#?q&qJ?3Ens~zn;jvmby7*w{^5kq0Q{p!#7B(=?87O)d-iyyt`X#djB9@5B9== zJK6(ZpZEZbIw237uH_oJpL6_UT6bh#w7_5J&RtFDs@fTVFX&6%m0pW&(B>wscVVcB zfx1>`AqNo$kx-yK)wRY&r75OCgYWNQ;rFRlkcwg&E!fFC9SvnR=O;T&7V_+u(9nn6 zd+%~{mRO2d0i8nly^2LE#Ix4i1lOWqg17$=PmrLQ!3r!#3~MP1dpRK&n5OSYj{RQh7f*o?qB{ zTdAJOlk3e+t3TIHOwOw7s`E~3(BXaF?Blf-pcobP{t|)kragUuYe0`jAx7VN{ledv zkyd|NmrE^gewU)V5~$9#IaB)fyXcj|dl}DKVSbDYs-~X&!iRPsf`R_4HKS7ZX;mBG zA}?sj{0&s)BxfOxzc>>6)yn!jI;VP-1k%^e#RN0WYNx|XKYkN8b9Fc;$gAL1wYl#Z z&}lAxV(sBBne>CRf<9C3hqm z8Sl~*IszaT6XgY3-OQF{P6M0{5%ukRYt(UfKsa2m6@r_jayekemJ%S7cD51?YF`+e zqcYrSRVzU>>I4~K9qP!$2&2RZ2mj2tVI~e2LO|g~uu}n8EGye|sy$Hn6hF@t=cqCq zVk>SuB0U^$AM;I#N!cd(i@jl6rmJd_di+x2Z_%~+n+i{Li$^=MofnnTFKhhRkA;E^ z@jshq9hD9kxzg5@J`|!tk{bgp62_MJ`Pg>DO-fVQDT0IusPxMvjv|O_B}b3N$$PnL zOc|Q9o>mO6F=yTi2JY_34rx!7Rh=G)-qWGarH(x6OL8I9_hjVbj8<47gl$8>WER{C z4jjapM2kjr5(KpYg&D>Y{2zVx+pZ_0h+Pl}>DoD=&{PsU#D0~$l_ml?b>Ad!$*>Dq zBE7%IkF<@hx+L;W9N(jsf|g?PFG+sd)iHNWBYoT7B&}A_xMSBeWYy4!S66-Adx@7crGw=Jqd5h1?3yWWbdwN(a zP4zbwKhK#tk=mf)Lae=Zz7LsOAaTmf)N=B#dsx?;pP++Y;nHan&l1I~D|t;A9Bq^w z#ryE{#g8BsQY_)DNfww663%$^eiyEFb2o`RyVh$qTN$>;XR;J2D8LYE8#;QjF>Bn< z*xkLnhi!ei>0UuE{tpZHm&VE!?iUp|FpJ3*mA<3Zelalk;+&b^t5R5@!})?Cnr>-* z_V-DS^`}FjGDQ!JrIuQCiWz^K%7`%Gs?E#!xIb2VDz)Jd{! z(d}l1(S^e1Nm^nAL_q8?L~{=$oJEfiemkn^XmB9?m(KXCvviV$BLBZ;yeMTX$Wf)a z={k9mPEjLQ-82cAv30T`hANwk@$(TkuqYGX44`zjRp>w*N$9fCq!8ES2!7+`xbUp>NuA?aw ziNOYFft%Qbrb3@Zd*6oJt*m-FflQUp(n=Z9KOt)5NX?tt_V*wDLm7T}w(+2d*4fET zA`g@BN^$BpiXuCQXf!<8#lZt+fiO$Efn`~4itSb+ia`ht0PP5zAaUTmoTQTiMlxZo z>Q1;DQy>y#t<%~_4l5_V#h25=BB=0Z+7ENG%}Sj7fMwl+_)6zHaowEi*RB?9#aj)(Ld1!c56_&|3FJO145$HZ#Yz|4+u2&%71Gy$v1F`zYewJJMRqsLF!$bdY%PnT^S3Q~njzd380P7S} z;uTTXj-c=lx;rV!6S;Z1McErMCA^hBIlCj|{&05o*Kgq??r^SN^xJPsQ|66TAJcSI zFFEmBkl(6E1(-iZuAQUj;{?Rx5{U2Opno0!{Tjd>Oo5*rm&W+r}>-a$;T5}m;(tZEN0~4d(BN4 zQ{MC3S(3F)K?L%F@)fK8x9O&)#mJ;v%J+uix!EXXX@Lm0Ga_R#NFy+4E^8iHWDFL+ zK`N)$VVpU{lQJkZ?xQyb28KXmEm!nshqV}9=S0o4JGLIhl9uvG5l3-gRZVC1)~z%g zyd?_(O!#rFueI}H{{6qgD7t_;k{hw^O1#Hb{WI%~iCRV)=81Bur?Bt?-pM>`lnn0& ze%?ZDyU23BA}F!4we1lJ38z;IvX4Dp$=_~Q3qra%A=%x#^bJVDYQwN@=GCE%uMY*= z*yn)Lu+(`|h$KWmwk^|;*%$B+8nOi1hs!r3)?-gvireg0czLxe`su4X;2#Ll9Cf-` zl;-zF?6zC7(sR#OqwO9V^JjdcXEK#O726MQB2U&7Sep;}pBw{>Z#e6(bA)d8*I#<8 z2#ciPOMAlSp1)dZb; zjV#54oQy?;Mi~{7pgQVjgYe7k6S1=vqeC&lZCFSE5ZAx{K@v(~H+@d<)b9R+5~ViJ zHPkh?6PNx$xAgv-|I!@6>5|w8bzWkLcig~%R1-lglE$jds|8p?LWi#K1f7gCs{j>C zygK)OCMx2P{ZJ}5hCp6n(*>1bO(rgO3`&HnoK#QZIFW*tLfD)P1bs9_b)g$>U|S({ zS`BzB!?S`ju-lN>wT=iELWhqF{RH2KER*)V>-rwk7i3YArz$fE@EHxJz2_vSDDnM^ z`$h9qWbm15+)kh)xEbLBehSoy2ol`K)mEk;nP(f$LS~(nnIU+cFj^xcK%L415Z5)3 zcR)fA$3kq~+#Z$N>IA?|+1z{VWamalG*qi&T6A@#APVhQ0$ox_Y@|lY88*n4+!l4Q ziI4yew;5}Lyp1WA;H;e$Vu*^cvu6?oK4iSA!Ay;!g^^-#kc{fUnzix5vK|UE0ys^0 z(GKG~d^S@k4~-ml#^55kj@DEyY08F_c2KGw@Vni(}Ev@&9tIonHM8RYlQCGr7{dS zz^2teTU&Z?peX9#mg9jzy%6_0m+vhg-l>M1=mf^mc- zf3)W;KfG#g)S?j!evgIi&R+1zLp$#-WgbJ0?^a!3DC0K-SdBjEu&k-r+oX}cRoVR5 zrN3~R^6N)fL4E+Ttw$TPBX~D+Ve`BB+SiNb@?JWd;}xH`c&?l0+C78)`x6)jzil1p z1Nu@tLZTxOWw|Aw-Xu=&s@P$B+2Uk^@_=t-aSAhA`=x@(u3 zm$YP~zYf;^utBYTrKw#s^K|7KmMPNRj>3O=OMW~3HNGnNPh)HHRPb5{{)(A?&|02d zPPNR2o@0o-G!PPu1)re(+&s`Xd5HFV?`XEoo(9hG)_Y9~*%9s!uIuIjFlitC{oEVv zKloeM9$P%y=Ohtvc(Cemi@`LC$XB0_Vmf)Yp3tqI{QEU*{>)3~j1bMq7g#*39{ufU z-G`jup5&L+-q67H0Z%{e81J$c5d1o(`d6-SNaS4tCJ~|Jua)zKgxa4%Ek1n~6yG@2 zKYZ-%_Ag%sHlx?Re$Lr8os4UJ1`_u|K?J!M@5(*mhtJNpdX8mskMy3?QrP}|jD#ZK zYQL&=pU=AYij>2qSER5vdp*{+Q&P;!ys!hhHlqzH1L7!a0tQknGqRjUcus zFH2M|p_D7+8`2vVn9Pt#T@?S8Kc=I0brKK#S8J#&LV7?Ft~C`?E$EhpLKnmtdx}#c5FMl$dc(w3KF!wjI^EP=8a7%g}a`N5tiLW6H}WT z7VXmeZivs@9zwS?93vq@ZnYjPY$-TRrM!930@fR}U#tvqM6DA$#1|XQ7k;|6N%WLb zVz<;^+7Fhh$^ub>2()sF%MgQt?dc*?g}G_-IHOJ<;BO#_sQ~%gmv`!ks}GJw_e%W_ zj1jOl^1QKN7(L?W8_i3No^r1X1zC1}&K3YvHKnv?hmT|mgL#g+m?d(`FS#8(@_kt3 zl$snww#HSpA9B(_FdclUa!&uHatzCXDOLuEbkvzQ8gQeP3TtE-5(z8wSUs{{@o;tV z(TgWhfvBy|C){=#wiEg7agMhu@$KRLN-G`tRDM(znM8xstSpJYQ+ z4iO5&6gJ^In`ik2Bsd979m#ghEP=*wwqjba%{W1RP!KKWz;8HDs9DU$PB8Lg2||ua zZ3(IUbO|mM2w9cMB-jt8kPKUa3r6u7i@a8JM=VDh{fK9mrvu4}p?63G!s0KLpk}Ot z?JSg?IZ8ycM*;bG6bDlzhRf4M)nLJf8<<5MI&>NrY%9Rxg7VP_+UqP>cki8f3d%Kp`JBsTT=5fNeAa-$7iun z2@8Zc0Y%isirI}>Q(V<(f`9U5yU$Tqpn1aXy9k2e=Zh0*f_2`IBbKB?iggg|tFvgd zVA>PTVirhfHw8=+x8T*s zRBLL&i@5$Dsf5ny*KSeP>E~qHKkwKImwgi7^I*s9JyNs~JcrOY%5)xgQs(+nrFd4_ zcoIV4r=2Nk|5%3WgNtg{la7AAvb2Aic{AH7Cs=v9ynIva8vfHZMD-z97yje7@u1oR zdLc2v#P&PlT#L1lTo>xmTZG?z*_dr`Yu(?rRu$c)$(A;u!Lmw&$?;1?Hn&3qjwBa4 ze4hGvaIw|jST*KQx@lp(4`NX?bQkqN?!v971(Zj}29w<57p@lUttkJLlpd<-#1(38 zjOaZee~yZAl2C9RJpQ8ktHp1^FVQ-}?pw}*L8MPdinIJ`2(@!$!zPa+_lT@HFI>4V~uV|r=&>`TY2N(Ps(vBZ_64!{97p_Ko;BQPw^ zUqOL%mzG^jJ!>R5UJ91!wI&m6+z*+FY?5fGY~g30Q1e3su`4LGpvW#e$oElAaI;!Z zYernCsb#~y*-?)>by|y1xWRA2(^JXRLH&OGmmLLa9{g-{4;y84y<}@jY@_(*nmPwI zxclBGiRIi=n>g=1XSXB8yO=hzlhS8$lfzGI%`k61_GknvLcI4_?nJx{Tuuo)=Rp{K zc)MxKL^GeOTQ}KL7EtsLl6nJ0PfloW3b`T%th6H>7VNoH06da6u`J)S{dE0?eIeEc zJc8oc1w-flr?&r~Y{!j;ASExp_MMI6M%>8e-pZ zrBz*TTjijzXOd~--mCbv98O-aYk*UC z7DPDNa2b!Pa;c)gJvg;fS$IAHxdWvhy!l#C1yF z*4zj}c@gznwK3~tKZ^#;6h2Lqd~KO+LYDI;!Is!2d`=z<9&2rCnAcPT2e*Xyd;_O0 zpyUhp;-wY0=sQa3*Y2L>go375+hq1ULHw{}oY}|4joYP%CGCU=riFD=g4$8I%eFiR zLHRdbO^*v3gF#0Q)E?0mbsL(81@?`SV*4ui_AZf6`i^C#Uvtv|Vm*bN4mo6^S7*t) zmOL+lwMZjtGdR@~v1MlnS^D@htHbl&~YTPqw z4}Q$qH;r5ykLJMq5=Eq+*D}SCw(!?y=beflsnQ*yuUc#dyK&}A%Vm_m*)5Uf|H=va zNqYtjTw5+Uh!|J++S~bixb_^bsYjn=TJfa*lMRkMIk-eehQmXqkAQQWKV2@sBm)OqLYWZjUQG9u|+q z13~QG>(7s**G)-y`BnGn*kN=i*MANBFe0*pop)pGc3(F8T>~AG3kpJwJKNrsyx-i4 z4fs@Uj%$}Gl8!NYtXaF*qNuM9js+($-$(*s$EE$ zRGQ=a$gHzDRIh{p-pSjWj$Qj#sf_ue*XOvB`K!3!_+e2oDhPT5?B=i9~%=7A)cP8 zty{w2IA86Qf#FlDBId{<>C*!reP*!lq~YX@L)$UT)V4$swk+mc&j$AK^@C>_al)I9 z*JNe-vmGN*w{Dpj0>1SRjpbi72AWnZCIEI%&Y*tRs~1pU#cTJQ-xv3k^qZBJt-8Mr z!=I&lAk>{jr=Fj^`UvTqJNnlR_YvXcwYw4>$Y0aZ%xv$JcbR7_wdrF@G z)3HVt2_6PbmrbA4=rSYk=zf2W6HSYtZ?Z?u_d3nl>}G&YieoV@iQOgsq1YMU-U4-?S=-yTFM2z#k%34$u-#UNx-Y6m$MWYM&r z?|_S=T&!^LhgqbZ+n0F93+fMkABm}6?=W9PR(&v-Iqq5C*gv|>$9c%+OESa)5Z%rwAO*6=<+P~NL0#jW^;(eTByp9CKV;)$kr5c7YVZJ?(acHIcLk z@cB#EE z;pxQ*x|nk7d0QopKtzX8C#WJEZFp)HC@0XO-4F;`B*54u=unVRnj2fo@}=(ViM2JW z@Ta1)Tyg>}qteo#=}Sb{*4?_g&ZYss?U?!ms+^ZY0(r|#{HNV4)5{@}yX|iB5RGn0 zv0%ZIp1G@KL3)mR&#c~>KQeVNbyC3EJ$mR;TC@@Jnqt}2OZ)Ag#I`@sI`}i&+`%L2 zOE=@Y-w<0pMG7{BtHd0xzY`4V{wR{;_p6 z3%1dEnU%G0;_m!%$KLe8P8mIed(O`R)^}hND`)KT`+s&zI##A?tdov~Q^olr5Ry6u2)!ul|Gfc;t9FMWw-FwPX2|i2mpQpf{?~_dGLd*Zf4a+TPDAM{}Si8 z>DPjHf6}}~Dym!wn|Pf}2aB7CF5ILw7lH_uT}BjyP#grGGwZk!fJk5XQt<1)`GgJb zf1}@`muBMb>Ewkim$`NGBQJPN>&)t&!nv}BaK;TtO(2g`?r>e*@q2NMeKhcuzZ};}N!(Ebbzj;4IyZR8x zPVhsinzi?p0U_4uJ)UYQb|%5LlKta|APjGzb`H!fhGrG9noS@rU}x-S<%Fb&wQjv# z2@06+GoB*GIF(EwTg_DsYVk3>2OU<>zpT63_44{RRjt0HkK@m*O&1;Y^r%9g0IL;z zoVy)T9Uu{$imd~+b&|8PYpfjPgG|F&4mXvPWA4?St(>A~Re0I3(T2F}2s;q)ANaGk3vRiOhLgum z2Xg`Xdz`s9W#zvq^My`Am$qU69GtWKR4_(%W&@Ui1fETFg$o_r2rjKMfa-R2d*_Nc}sr?hJv@AJ-ezILGBRJJ!EStaGVB*1^ zL#zHtS#tV}H11{RRT7+GQ+XgupYaW!**pVw3Wnkz)GZZk2l(u7f|!~lH}&y!FcEn1 z1)J2O+yRc0P?f3A+eI~9k zv%_VG(XEIRH3HWS*wZ42t^kpaAb8E&m!a<K{MNmY2fEfrmkg&gp65s*bYYH1Mg%~WD#CRVZv z$XxCC?8@^nd)sIcK{z_NF#v?WCXiruE$#SFo=wC)7}Mwq&tirEU~2#h3w&S{pj`;c zO$s9ntYHIM6emISCi`Y)R@_SC=k20`=!)OXfU6gT`EbzDn#SBJ6$6$F-3z%pIC}fs zGNq^I@w3yH$0D&{-Z-9r?(_A?h<*DV%{YWk2}_G$-b=r?S&$-bq!gYsc^1DYNh0 zDS$Nrs!H=uLR^q=ssMu6N)1Y%*hNS7s0;?xCkO@aD0JOb#x{?`ELHlcIr zx=nb<#Tv_kr}?JN5N7C*L=TM#`Z5+GyITYl4`F*dCze2NMy0wVv|BsEDFB%2bgi*7 z_8{}}!f#vmV=)NCv_8>*t*}Ut&g+`p-TvUhw&=GpPt0hXSI4mN>ujY@6$_x$A$8{) z)7)q<#P`Id;>)XA4pHtCCn7EiL~HUQ$sl^Z*?u_S{doGQ_IgXs%+WuqBEKJH1U;WL z(DZn-22wz?FAfQJvprzGmmJK@A92z5q@68QNCmv`i}weit^Tw;D-~-_xT% z9R1AE<(%>D%sZ-QRA1nf+G?KCEsN{_2MkjeRADC1{{-%lCda4t)Rg=xIgR@A^3IEC z>esU!71a_4bhf}@GC6-Z$UEyQuczjP^YPcA&({vK|3Mh(tSxkBo`Aeg_14U@t;%P& zC8g2Viy?TS2WE(lvqC^P02Kv5_<=>IeEVI8BiNpy+o1c+GQ5swV_^aIrVNvm z1^kdn$spXQks>av)&Wb9qDyRR&^Tlla>&pL(!yUod04fW*I1J(V)V~GwaT* zB});(TEavk0iDU2wKkPNcL;YqX4l9}BzpM*U4eZc*c7{+K`|yL_Any5@7!ss1heVV zXo;@;l?T(5fJQABu<5fBQ&<0NDr@qbMrGjsUsWT#(uCc2w z{R}LmaD}a^+H?QjyKZP$Jftr>6O~F2<}$i-+Ndxh zPE4T#)}Yu;vOxn0m;%X4JpdNK1~yh1Hq+QQqXtq3F+WT!)Vdp00>sc7uOb>3C|W-w z7q@DaR_9BK>ldP;e@ee^A_La*@m?r=RM(^VV#I>evHrqFRnP=6tgJU}l^*E;NqC1{ z=>A!cT_!a|-i@0jTl+7Y@0^*R-){(jABy|?%>D6Q*|>rfTb6jf_H8--kuM!Bj5oOo zTStHn(*Ent%`+uW{z0#0ql-#agVh+_r~R@kU{jKVEen!yS-0=|e|31AvGZ)xmgg|36ZosPJO4E&KW6XwZV%nvcD%+99uU*;Tg#?ODy zZ9fw)wb-v`PEK1z?gz^{wM6Gzu4BsTd+hNei7KOp42bG3KG$APHy-=ml* z89Z$9&9^~iz=}OtvebO>_=HF@qq>a!-TifOPGOniYO-9@NOZd89PJ3Lsc~*w*wC-={?aQ)h-n{y$Wh%mvdtRU`9ECxDdMr2np89 zxqt!$<>BWBDWGh|(6JkoxY!aUqHyza9*YprDnP=@iFmJ(uguu@(e79W|1VM^7v!4_ zcPOK;%z*0SJ4qL(m=@XKp_rV$hfICC!x^p0kKdPMizkOl24nxc`sr@_o78xV>wh1F zHHXPj^!sx7`J<*bcu|y>Q5Y*UuN6WRpyf;pReNa4irqKF1Mr{`AV!dtA}oSfn-mmL z2!uTUC=HkyN?NqFfs=DN2c1^E1ZJ)!mdnNzkhxHFtpoBQn-YvJ0H4Iv zu`n@I3BVNB$&f)4p5%yb5y7@<18bY|_8Zt-`k8G_CGaFUJs}Vh6l~u+l**V$;KC>s z@A!`v2n>x8%+P0fd!KLn#+#QBN?&>(>P);&#GJTM@R6)+ctqM)W}|)DdEC3)WF&t? z%48l_KL-*-8w~uU3Ce8|AoHz>=wmR`Y92Jx0AbaZ6kKB!f0XDm^a2kb{{oGb*P_J~ z3x09Dhqi7@U= zAVD|oftVppEVL28$))Z9Uh{r{UqLQ8pBQ{U@PV8K5sQb!)5t4%;PGF{%cX;-d#2|; z9cuqt>Bha_aZQziI51dD*w4r|?D|d(zv#B|p=hh}Skpmy)r#Av=luOvA@h>pbNje3 z2Ps0LwX+Px;oAT9s8qzSx!+vamo}SNi8ULhFREx&P)`K|N0-WJB@GR*EYs9|{|z(e z>TANF6{30Um>aTKuV$ax`W$=0s(Mra)?(_2mo`pIDVY+4SO22b{kE@)=uNJR-2M9A z^H1!Ty}L@)t8e@V9~d~z|D1xOPZp#Ylb74hwRU|pDn9-2xy=eOc2koZ{(^K^;O&L2 zKhbe21HWlYoRKP*QTyg^*OHD^ncXbf@-Hd4cMD2sUY|`h*u=%Py)i9p2%(IuA5f^* z+|-FKamv=}$}yzuR4fdTZXFn5RHkI_=H?(~iPc;4s^A5F<^MGs|Ap!gXN75ti|q?U zSKXoFz<$0#pFqc%X)#!E_sy=$5>Ysy?eg|sBLx%IxQdR-RTWZpRb0V= z`u{$K7Mf(*3<_TKy`Sm?tt?VcZPDdf>BH~z{y=?$Y!l`mB zM=JHw?P2qwO4poKDbLcYWm>DbH_v%o+MKx_sM6hmdwzmSymaWg_tqZK*(<)q$#6wcBVH=3VMt5iwUuOO&M{+I1{M`ps7u4V^oNe zVbCPgbrvKc;DAn#V!%d|)X{#~X)Zl9ch18G%OL8jGcErl!uW(GUs(AW#Q8{xtFA9)|cK%QLB05I4ol$U@t8;gIA@xn% zuHfoZ?f-`4oyCuD58`U4nGf5bz*?Pa2iTV{Y3Em;pRn;a`)*i#w#M{N;{!(EdD{yG zh$i*4;jYWzcOTbVjqHk+cn45uz zMAw1|Aa0c^z6F$}Ge1B-fOl!Y1VFO6baPEe5Rey6V1GJA3?x}lz9Z5K- z`@vvEE$9D8I`?>{-~WxjXPC3nDu)>&wxk?ZIUD7C8j_ME%Bhn%o3K%6Eoadh7IWx; z6ru>_oa2Z>5^~IWO33GX_xt@>Jsv&A_P+PJuh(@wuNh_f`-Kr=_NUVE42`Q9N57ms zI?3byN_|?nD!9Px2LAi2s*q!kULiTVUu0~u(#&JlE3625Kgc_n5%Cqbz*1t^orDDJArS>7`Vi!mZxd zoV_;;cF&4c?%RPPB;NnC?}*um-Xabpso637^=4rUc5}z=X)Qs5URx!FoBbcvPnbGz zj*Uxw#x#65ojlUHTRgcx{5S?a?61~uKbRgGW%nl41hHHzo>E$ zDaos%=sg9Vn*jQUm5gob>pEkZjn#qg^Jn!nly-Joj>s(j2hCWT(^e|GCT8ub8&Lg; z%@NjWl=0hgLJ%sE(%w9H_ba9;ZQjLv*xCK(cFYl2^ zvZ#h^&|py={@>rv?{n|c3lPfI~7(pw_c zt!XNC-jWVDxQ|J8KnQO}mf!B}CPCoZ@-UwX*LxyDVpB1@9{yrRDn3Y+$$}&8y`D57 z2{2ABZPShpi30PSR(FL2sD7la8B4$`ASG9CWR0CU*^8ZuV*y=ESmqAW3kSs%t0;o| zumA?>8LK++`1$mO=cbpMygx}%?mm(hJ*F-xr-$Xs*JPnT9pvAhwML94v0(^y#;oZr zwg*yGH2$32 zH6c9{rpQ&ENo)B0E?~o^Vsz~oJ*s-jw>R!ZR7zPMyK%O>L@y2wP)OU)-YQX74J1b+ zo;8L*XgMyqjiA5gPcFY=cq&Xvx+$RSQ%zuigd-+e3>Tm6gxuCFU#HR>V1}Uo>mzuX z65U8)G0}nA6W`Yh)AK(1nQEAsM5KBAnW||r;VZq`bGRuX&g&*^@7;5Cqc<~mSUnnq zz^Q~$4jj+q%BWE4%ZF!|L-1Kky49LVI8gERX1G0{_`d%3<;{hr(fa0tBhMI@Iqt4vMv#baC@8rLS`XlAoEE$z;)aE;bEXaqGckGOcQP<7&5Y@V^65+EVG)=e2ShDnJ zf)5PITmeiX>i_xs4X3D(7Rw`n!RG809(g}HaLz{G*mFD9n>Wn!nP!fC)`wfg@-hR@ zbnY~t@*>w9N*#P5CV`QCo#$hr8KCs+2vk+Z>H6BwMb$4`kYYniiSu-eD{>{+a~T^ z0eJMyqj!#-c9k8$&piiip3(?M+w_Gi!*e{O5DO6uyzRz9VR?5BvZ%QEtj96qy)isn zAG0+}23ug4!_RgvKRY2qFv#~OnzZvBHk1}6ahtxlOiB9Kb6P&UdhYy4|I0Yq(g@$p zuK3mGon(KE1kCB8tDa9=iutuv+G%Flh{f7a^zio)fhRzQIU6hg)<2mMIDW@2rMk=C z&!-{th{eiCg6~vff%!9E^eLON%7N=0BC7g1&RorQz%WQ`{Z*K7LT2`Y!^VC)yVW-M z8Y2!2uUgyE#mZtYLypFv(8hb1rjPQ>wTK;B7rF(YXR1muK zP{6Ea@1+^&nU z3{B{?^)%SzFLmN3SV)`q_nMDJ-^op_MM4GD|3MOr&@-IGUs0Tc#hcUH-k+C?zkQ10 z$eB|nUiyDIw%=ja!QfWEo4_t1P+XyhwTa-7L#>7un0*+e;<4d5&NpwA!v=0?x2`x7 z2lmUf*T&Wad|$i15>%x(LHrL&nBH_MOGtwRobjOmD#Dcz8?&Ad9DvSi->5~x35>su z2?ob5E|(g0DaUN&Qpzn)w0x~!l*O9SO%e(2zXu^w@*GcJYplS-*q9$hD|%jUYj=s6yJXYl{&DhH2G;~p-tctvY(;?o44ISf`OzBC+-rl6Wwng z0`B50{j}RXILxKfiyJ|jbBEflIfj>bAbR@Ca?9kwDuDKaCBme9W3ygfVkdzoysa?k znCwA#Ehx~KWjI1P78VzO7%P&2F+)X;1$l$JyC#$S7n9S3nKd(pu1(OjgP6&t*9ID4 z=(O6R?II==V60?;fx2f+0_c2GiTMyRkl6#WJ_QewdYABmCYsD%aDZ#Eq_y%l0}EgS zDKs$iiRV)7mdwuVvY+&zW2SL@|4L%h(AgZJ*r~wE$_HU0Vz|TK@EWcXA%4G4sCUZ! zVYx4?D=F4`G>2Tgvizx8MAE)Yv~hBWJeZ`V_3Ozlb^u^!?83sqq5M|wY4mus;WX9n zN0`AK)qtMf6rCRUa*aoY#Dw1L+m}RYQosQDsL%2LpsW20*Xs>x(w&yO4GOLfCmTJb z^awdU*bwP(2_;*ZoZS~XAZsO}x_@}f zX>`1Nx&v3*bjn0M*&MvS!aE=IDZfbf0FI{jc`Ry1X|3eoJ9jn1145h`TT-Z!v>!I# zY#K)fbbRs-H~Hx*H7sd$;OPP$xn0VT%xY;XXAcxOPN*A-)TA%CF0``dvv{Owjwji znKx|4Ny0u<+FyIHz(*}U@X;xh`@!yh+JJTUoxmmRB=40&tmQu_QR3Oz3Bk94{J%mk zoaPZf=#QAdmxOo}AH6lWe}6)HT(>7|ai8r@h4a1Ufy4oR7>650(0JN;;#g`yD7Ei& zm8#LpyIc=+GT<^7n=5wGAcAQzl7Qf!z@p}gsOtN6Z>G91Jr9|8jS;D{y3SkcuL<>g zjW6~Y43vpUKld}4gKnRaKG|xbW3OIhJ-ng!^o*$|l=N)Dt}8|s+@lAXeD|b3%TtWF z1K zu~I6D`6g{-v)O+4Y?BbN`rUoFp3inkS|G%==Y+1LM2)Gph~`Mt!DDmpYf2m3Uf*5# zGbRsS>aB^*!KbihV=f~$xJ4t80KMDt!`v7;Dqa%M+=AZwX8zwPd|_8pz`GL)8)xSK z{`jYKLZP#oN_xU-v7%hrv!E2(7NJDtZr(FWZ_)K+gefr`@NG;Z2U`?-a{3)sgnz6D zVLm3GD1I(r$PgUH$HL8Yov5M6iDvCk1Op7vt=C-#tspQu+G8|8&TV#x_L~WeC*=Gc`JF$$3(t}^5+2taGT)I%1J?$8H%h*=LUmd1N#m`?Xllo3k&ppu&ps`mGdfpQ#2Y659J}t@gRj=n3pEpl{*|^q{;goVqH5GjzOXt`t znYN7Ws{=C-vUUa+3}SV?ITj+sfd^zUisfhu8JX=P>I|&|W!(;+ONP%IV^~Xg-T?e~ z0-hm;!Ey>aJyPUD5ob(pW5nPK!jkC%#YO zHxWkeZqk9hGEcTNKfenD2eRf3v%J@}vS57yLW+W>zBWXYC;>>^^A4ED0^Ol)TA^~9X!|ame^=8toMD;fAk*o$DTzco| zpe$-{gP4SE&yzjd<}V=bEk%AASFS`TONCi}TU^;*b6NTR#vTvSP}LJ`hAGOymrMZj z|HLv2MYE?+A%fnM536~vaqEUvdvbgs&c(Rn`PWJo5B5=@*4L9pq)zK#4|399NHb9E1&HuBir(JU?% z!l%v;nC(xGSV+!B?)i(steXw`9ulEKg_HII7j3*@0kg((XpSd&Uo-~Y?}dbR&$~n= z964_6!#CH_VG;pU2l`J@8)foJ-mAHy7#@%NCOVTTQSUP!eq5_!94FC}pn%o;?>IO8 zP5Qf0{oX&>9*7eCi}Pk?W$+_vG;;VLYl9?*zIOw$!u9Rpv1z`dm)~FTm)gHbY<=;X z7I^kkl!btb$UiJR6_!@vwA;tYCj3+jr&J|HZ@E-SzGsjX`rx9HQI))w+y1o!H9d(B z)3PO_jd+Hp{oeOc4~aP`pvQVdL3v0^O+ZcW3k>vHd^Yp{v}ebqbgE^}`0qAYgvdB5hLPX*f?LVwygq$zqCtRQeZ9xf@mdwVyQx)8b3zS3boVLekbs{A(ZsH|Q;{yAa!D;*Rjm$RbO&)bx*Z=Ld z{H>@rd+S!d+auy0G_Z8nEE;cg*I8Ur2+V!&=3k3x2HAFqHbvR^#Amf>Kb5o@ga55d zKwMZJzmR=|5|F5l-9Ntyq?a#OzciEzE$ikQh|fOP-hXAgH*S6JVjxtV2jp(eTnaOP z$=nj(h^qz5$Q~%bbPaUw5|qiv2n;%|Rs{}kvCy$cd!vYWgtM>&hv@);%YHN1Fe*4K z7%PV56-`m@0Wcv3Nsv?f)4O30R@cDdFqMJxz(F}(iN!~-YIuQvG>RT!NN$Q5MS4MU zXQu5jH1@no!y)J&k=eNArbXgH>>Qy-HMWTZ|dfn0bER6v( zG^QBi(Aa=^JS-Pz%}lO@k>0_4B-v(LQd^|_UHR<@3|`t>9;gx#SW1~$WEw$q!Z}IF z8R6>VV}gaEsoHGNDPd`D-U(^avB26U;IdQBup1!nuRxNQeZq-N5IB5s;p~5l*eMDg zF#w$35>uI(C=$?>Dh?_taDTdBGIP%7_kJY`^4hm}l;hJM+ab49Zt3^JW2^kgUK^%L ze_$JI53lqQv&-pO36^4w*{pu0#9|Tu5e{p55Gg0X*R2>GV2u*<)~g=R6hZF9JuafO z4CMTdbB3a{Hb31na~@yhLyEDrndnK%U*7`a`m^IsrG=wSL40RY6h|I6JL!*8^1iwm z$0F~O4&9M4w9jd-X%>xtlah3>vhvbGb<~q*y|>Jj{@$Q#F20JQ_Gt8Ajfra8CS}*c z9)t*Tt^mTD-8Q~=cuD2`%2(Kq30b=f(^4CdyfJu+*!l5DRL%XJy`Bbpy;I!oo9y0M z8Qz|OU;Q)ST1WhKUEmkq@77D^7MNcx(PahgQ6W*+zL`61Uqv+k?gf-@zKP_sod-(W z>zCDSSCInKjB3qhU)2fCY258fVgg299Ps4*7gQ2B<66I^XP*M(P5Tzn;%ov26XZ9<@c%)Qlh;3IiyC$x8{H5) z+z_HA6ZXk;OarvSyv#$oQz2~uS05ftA&`v|5Y@H&mXCyP4`yy;pLyiUfTf=i`~!2P zf9(vru%^IhETPV`0qm5(a(oeYx$XvFWqIm zy9+4=6wNQWR^Gbx`!?5b!&op_<63YU*yR25rtCBU?LZtXz4Y^l?>;WU z>u+Dj>O6wOkF~XZzi(~W`KAomX&OomJ5d0-{-gW*Uq>0mcB8C%i5*8NpNx33l=dLI z5jh|lts7yhkg(3sW2YopitI{7drS zwbdtZ`K!s>MeqTC9rj?l@wnjREx~F>;;2znmP_S|NYRZ0hQS>YpCa8v{6Q56I(62x z7(7VcP~L%<`EzgHy%I^}_V1uI40{VEXad2KohPmQD6#p?)uQ%}nu&Co2?x>rK0>^n zL5Rl~Z+OV?vFU8x!$UQPLS&fXO{+kG3Xr^Pet3XIM>L;3a~*7 zaQv=z?V#P}oNkLG6#=2RZu8SjY-W-dUB`}UHO9tVEJozZIAfq=ouOm!?_mv#^Z&Ah z<}QN?0sldKji2Xh4YCvw$=YP!1DfLn#B5(hJq#Xqf7mBKvc}<6LUlp5=)gmH5%bnA zEWg%tzE*-xpY1e$f8c%d^85Cq8zu);-!0s!T$~W^644%vKs0Ic{r#13;6JDub90I( z?4dZ+7dBlBktU<|1bS`#`VA8Eki#~;*mOk@@28>L9yJvIA7nLnpDO~>HjGD)W*=YX zU45f7D3D3C4J82-sLffDQE})efi1E`u)sHTAr1|4(2z zP2h7o@U@}agtzAK+GqQ?Ae0tF+a;obcQKXC#xfZJ79^tiPYg^j5V9NAUC);n97saZ z1fY{G70AK@Vc7o1jlj|@&RyMF=g#isuDI1p7f-?I zZd^1Xm}~?DTtBn6y$fKVQwXC7@FUJ($%oHmMB;!m?hipZmegxbCFpsJ6T;?=Wh{6V z^~*izb|zZPWVKEeZi03X0dC@rybL##8%q3PM%rQnAp;07NQh_>Zb!2R{+KjL46sBZ z+xBIfJ}!7|Q!es@|IA}~`s+gpzSR!&li06{rzK1FuNCw61)2`iSv;p=$pY!vm{R9t z!@Y-d0}I_V3kPxrZo?8t_8x2bN^~0^@}4H8zEzNN;nCu-CTfpFV1>YeiTG)&c8 zY&_BYA9Vh0Ro6)~$B6VuyG@umC25q?;jdL#3BWU2O?=QaE)Q5+O^YFz6(r&_O=(gp z!zyqJX(BrPhS3Q=!wt>a-~=TP$N%)P0R5<6zubUz zYQ3SsvN;efpE#70BnlL|u(to8bwY7}YEChPvErZ{lB3JMc4<2}Cj1mZ6k|W0z`+jt zD=zMZms?=RC?IzfxsS#MddGnMb_`quZjlUHJzXe9JRN@GZDbb z#O$R*eykZ`X=8D{Z~{+wTV%I~?$_h;CnlBKKDLt%HBSy7I*6HrT&864Te*u z?iY_WKT|6Q1wZ?a%Mwa&`tFsvB-9n3MDIMUk5>0JdT6-S;Wh!;V`g-fV5#Ts-rI+v zeJe01Cha;l6)D}HYF3>x?md~NeeFV3>tsM@5Ha+FO+f6qq^%-@)*i$uy`txiEBYxd zywg6w&$Rx)#68iq)?C#t zNom5z?ox#*^yKge?H7D=@Qmp|RgSc##!ySE&bc}}E2~K*ms@`burU!V<(&=6 zLwBs7wV!*>>O>4dEdB)aHlW$mnOoyXi%%Dkf!466RH}Eh=v5ch460O>x*{s9lGUtN zRh5cm#l;i9AJX&PbzWgIl|lH~(ZQhmW(aMlfN0a@n9(`8Zpb*aEkBKW=i z`cAKVz|M0J?;iETNS=%(KJ&xuz@tvhK7Z2gCN6P5a0%W`1{D8fP;#i>55*0o zR${~vbp8gAI>Z=+h|ii`q`R!Oj+3RTz@_DD3v%}w(af|KI`O0v(+1>lZE%P5y5VCe zvDs&Pkwh?D0DZ^Z$kA|zF3oP_$k?hk@VslX+FEdXVg}MUOn#M%S2}KJ4z)))Zys0t zCh+=c%*7LrWv3sP=Kee%asMqms~5Z7@4(f%WGoGQT}U`@26&eHYOy#VEQr3RP0^+@ zdBE90Hxl_~0caYMA|e387c!OEBWd9*%;g@4Wc8YaGVxk@wZPfOBbW^`i^zvf-1n%$ z5_x(>5cqu=f*+HhwMh{1?goIzZQ&zfd7~82b|EK`5Bz~nNuJNrr%JSAhM1S9qT?+V z&!BT(wXYf$yEyVYTzjtLnR`-B&>m(ooY!T>$|IGx9Lp_XB&*i9#n77 zrag!C7?R}somb~zs0Zyc-?$hKWroq^{RQ)d^t_fiw^Jk_i>N&8@sP*rXU z1uwv(bi;=P9(RPrNkbfA-~M@XV0{r3r0b{UoV4IkKZP#OrGfRH8yM;dB3NO7gX82G z#Iq)lLfr#5njR#E_}d7WG)C2!Am)riX^GW$^{)24lO6q|ZFT0UpJ(b}gDIPLD_qhgW_wHM+UFF@wZehJhqQu6j{4M3l;WUj#RS`H_9fxJ3dO>h+=Av!Iuc{M z&C933J>YSEfGy;nbhH-3Ex?V?Y|9t_8OkJw|MjUCE=(|nFqd9S@W!;SaSEdO8UV5D z@%to%1!SLx+QVk-M+x=5R-yY5%w?0UxVw5gbzd&DN<7BPb9+YPZvbMQRSJN9*uB-O zeG&n6VJ#NqQ}JR)dcxr1GuXB@F*S-6H;i#Qo|5UIb00eQ;7>zjDTlib@{e;$6Vbw4I&sU{8L~18&p1h7 zGe_Cp?^eI?AgH^_fc?ghokmA^q(s4uoCL#_#+jcS@|5m)COY_>nk#1Ah^Wk&J2axN#?D8TgNsnD#LmM~JzpyOGM$#_XT{@#e~i#Xp*is% zQ{T!m zP)_28i30j%(N0j`?~;oxHKA9w5|2d{D}3eijy3 zxl;_0F-5;vnjtW#+f&rSb@8P>)$-6G~kb)}DHeV0~ymG$Dzf6zPg zi?de3;8I%q1g2k(1nt;ZUAuuy(5S6chpVk-a*Kn1DJ%vlMU*xHQF}ZszznVs1X6eF ztj#{LeMz)U_EdBPMm!5^&dMw1jINvmFb%n;StwirU@rvA%;8_t_s zU|=>Fba|RPd0(nh1(Lv(oZM;TM1NF^qp>k@H@`a`$q<7l_aV+Wkfyl0U;%3)^ zV>*;IW1fhMU_*0h_L4&OAnfxR8SAEVY0PEYvJCmkfceawjkgYYZWSb5j}r+|HIwkRqn(pR8XZW8n-W zxOivSIF0Q|eo+w9DbWd1yl^)Z!J2#1;X*Xl-4AMG>11D=*!os}HF^Y9{D#M1NhWjW zwv()xR;TNy#rsoF0{m^PQZxc)vkfdB|MXFmod~heXlqt8Z^31m`nqAd2Pmm@f@mR< zxeLTzDU=;tZ4s1g<{!|_MMm0_L9bIY7^l0Pp+tmi>V|#v*~x6I4auDhI4ID?lLOgE z+T|GQGu;ZFIY|gjUb0j)zdZ7hfBo-#o`+S)@k0GrGGwFIiP7u|E4Z^j53Rpp4M}jM zpETg5>*b#m&|rOZ(w*To{|HQ#h!9MA_DA)k(0HEQemDx9u1H7{y$FI-cVy9=B8e-L zE1!F|OjPmGO}adS3`Srl6pZF2S3U_a&^ePzd6qu_><`L%Igm-V5a*px6NKM}$lwIW6BoFzii@F1Ii#NDc7=Dc z6`w`h&%GhmAA5Z?`bR)=AkEb1bmF{SLqU%4g_elGxs~nKT>WbKZ!_MKI(SXy<{4-u z@&Po;E{Xcwz4}ZoG{ZcJ>qzB)Pz}u>AAal^ZRNv0db>vS+Y6a85p~}$9J)%noD;k= ztiK9YF3Bsmau;{xZ=7*FOCBlo<4zrkL^gKa?C|cVO~UJu^|?+5+w8;p_MPxCyH$|*q`BGK-m5F>P{&v$@q4oLX zp_FqckDnI$Rj4DM6<26Qv3ug^S5MAk>dgqZIl|o@{JHwMxL>8*G9ex@>#7A4RWP$X zJjbguN&R(MoS;o0RDpVD6P+G}&V`5qlWfVmN>cqABWC}De%W0J^3Ud) zK9$6XD!nSo15@cz?Yv5)U^ud|etvjdC{Qe6MeW@*p~=JRHNrboV=(0_Y6A5mcIYoo>F zRU2;cy+NY&B|78703gGoR(w7iY~mWak^8!V&yNE7&zrbGPafilE?`cXkyb2B0?c?I zTq@PZj|bbO&2}3nBRv?vuZuwN#w3vGkX3NLG9^h3kLKhNK}Edb@7Rc|!}>Djbq$qd z)PfK4Kj_=FsN&EhhqonHKkrDIoqyj%{Cz|`k{VSE1xH}P4pIZC9Ts-xJ$8QkQWDDJ zxH1KS-T3kp2o}lQM|!X`=JEV=4NDWut}M{g3h+2;I_?zH8)?iQv)%YvV{|#shj-p6 zx`hjPW%hQa6L>z*YnoQYq(UwU93ntm&;Yl>`lv6Mkh7lnXtP1?fkDvo(ai6{LhgB4 zAx7V_%m<=RV5Q?(y=EU}?cD+=sA1xui{b;p9>Bs$Y=*r%Z-p`qWwATsnUs>Nzp9>dEI(gTYGC+IM@aP zH)@Mb`BFX<&~59>M507|3=z8a5hlim7+&DLeKnhEd-2ha;kI7|B=?GK9q*$-A2l;C zOTblsx!SHWy_aN{6_c(X5NkTnwfp4D*05{-pw7iq=|d-W=SNdJ2-<+fip4y6%%Mo) zgTaSzkDZbo->*_$B6y*5zn(&0%rH){(y9Lbt`cH8S3r3vCOlz40+ zKFuA@j)|3B71n&Bl462^oxr#PROMVf*{lIcLH_Cr?`y}n0Q{|q%?^J1>B;v+Eo0u? zn0n`Ag+KRpCus{HJo;;t5MQ>ne5)F+9ElRMz7hPiayQ>$**NhplBKg}!U?LgmO0K= zBmyXi5SmI`_U57mG2yyFQ?b{u-M)t^wnvTcG_oeHUHg`=rtvXo|DLZd9p?{Ddd|;T zJKS4LKV&FRMI}DGC)~1%dy&$iO>9t1iaW5&f8?lh^=0(=nO!1i+Eo9H5tE(2{A2z9 zL2|CA7mHkxR+=GQTIe+Lt6j#y?jdT@T1_F@VuT@ccQS8s)%vV!81LE<51FHW&9%z! zd&9Jap!I`~KqeF?EEzk1*y?GHEIPEG{Zra+z)$9>=<+iUPTmmZVdD3{*tJLEaa+vN z)nilp<8y92+;!bJSRjunFhTl)jF3q_2NtGxA?5H zWVIe(qBSh&R%eUtElO2 zVZnN2E#>D2p}cu2cauuhwDc1Sc`lU6phT-#>@V>1iRb(Wabb4q6@)xJ4cgyOT)HVv zXsMHbXV30bl`sgngUA|tqS>W^7*IhRd8}<4SV)qu%5c6$C6~OcHi%b3ONj%z(>!QM z4^#eCum?PqZUL?HR!X`edfo@)t!1^C)1|&Ae}*x6bKcX&f>>JHSdp`n1g?FYS+g)? z4Jft*-8VLV2$G04$)1BQNL_AVa_gcQJ+}FB-2E zL0^{vl&E`v5=FbeDYMKJH366oy9Mj}{G&9YrJ;UWtZe?gsjptqE}}6~zykslJ}-dh zh(YG*Vdg>VRyD7#LV6>wf~zVsze)NIFIg;A0yl>T0_$x_XAs)Q^PBj1OX~nLV2`aX z$g+4XGkH+xa+!KIe1JAZ-e1PTc>#S`v;rCY&j*&F2$HUNLGWqM0-+dtJEJSZ8X{jh zPZ7@?iAA9s9X$xma`OwOz=vEb>T4UxBS+b^w;!8GHPfbxe|U`yLI#i12wZ`@lqFLI z0pLJ^gA|QRP;NT;6KYS>5g)#BYCi=SVz4|qz*4dbfY4lN;R29Vuc%?Cc05n&=>|IiV_?lds7P@4<+R@Tj0t@vM5FmRTz~LpE3C z8-E|@`!MM5#gpp(_w2$>MJdBcZer{Ho9nezn(F3N{|fAk)ik;~Zf6xTXAM2dVaeZ+ zx5Zj?Mf%6NN|38Qd|oD+4f(=vQ9^7kGjvNW)(GzgOh}ok@HBCBT7j_^G|`8v7pG8~ zRLN?TWIFWXp}^V1YspT5_Y5k1E6a!#1s6U@zv`Ynoo=YrFkKO-FZOy(_av;DOId5X z?5{V5(}c1gPx1hPZK&BB)oa)U$yo4+O91t4Z|eA&;qP1Th}Fk;E{o1PkBnF6NZGje zrX$DNFfwHB|DZeS=cXx0vE$KtTlPp&tB5T zL@nMH`da6?s&o*a-!CsZqd9-t;tdTg7^0Xtw`Fp6qR@by)cZv#QR4Le7xv+IGLknP zTekyz+XaWfmhZQ7Y#_^9_sX zf*%KJKCw?Z%B7XDhO7U`CV;||Hz!ooTP0O;ILC3CwwS7{9poTcmCRkLrcg;0k|zjCkycRg@HE z=Zhk9MdDGO?S@)^@Yi-sp1wlgMmg4Ns6|3UY| zHYB=`6Gg{HZy5!uxZm$rez9!MLj_Rf40K;0`g=buY{A!GDmle(7NK#oO?Pv6Gts_HNokwfsas?~?IM%M5Zj)9v3i>J-9&m0l zp#QWPbE#AA*Sv)=Z?cgWh}+<@wt8SWB+Pi?8Wpm#qpF&Lvzja{&T0lUrtLoXd9a<# zK&NFX8$tGLaPiS5?BACPUUU;MM-PF$xx|9GCHQuOtiS|ckUY(9voEJS()5n4W@Vx)Lk1;k!=w@5UuwrbrbG7z;uIr$Uo^k zinb(YV?nxW`H(Z@j5QE&-R|L%TuYR3xf>L!LTRO{G?MlijPa1vj!i}$s5+lTTD6a& z6>VaM4ARxDVib8r4b4!mMAUMeBR^fyF_C(K>z7gkrfIy{QxT1X>TyQQ53Ocjy~!8t zNoqq`5_9~ZX&Acj{PR53zV4_Ju24F`)Ym03{j5L90lNDEbQC%HjGcWw^0mWs#F!A# z*3BtVAk&D0L$&+slf*ebS9Hr??a3iP@J%*mE|z4U3@{bBWSB8`FCLl){CAWc$b(xG z_4TR*Dw935Mm}%HZ46%D7|hvd4!Z8MYgPV!=w^yfO4oHhKJ&>N}I4;)S65tvZ}`dnMZgs3sLTwXCoua^IITzioqdA zSbVoQ)3hYiIyls|p4jfS=6>~R{*_Q4qm2+-IAs#M{ioQOm%N@Qp8J3jZ!Hs_8x4Zh z^Dc>v27jPaY6Jfc+s)X;_Mu;L(*3(T(E%0xs@=s<=pNBb`lau0oGLzk*AsAA?30sO zT)a4G?2u7U7rH$@WY)c<4(bxPU$vMG1&s8Cby<^Y>V(TP+AQyt>p$vG{NX6`{eGE3 zOHq4XZysW^2k|g_Do@XbhlI-!QZSfXKM2zQr=psl)P0aP5BM>9{zSn7DA}eX9 zr`@CiTTDwx)X$361mQqe-l(HZL!iSc_+sbTC}-%mp&>Jvx#a*MMT})}c~6+$I=yDz z$XG7W2m_)!(||OC3}M1&OF>inwMUcQ+_&wkZa*e0vYbWi_ z1~(E5KHwP97J!U=!r8&Irl0`m@R2aqb`eq%(lGJHfwP@vN7Yy|0mL450ASEFjRmJ_&4a%MHxya-%o4@0eAYJB)PifmTPuJ2X-Qu2;qt9} zsfk}rI$(=<&~%`v7-o8}G;(-cssJG;^%3!R)FAt6mR`hMc%08cFR+(OF<&C=$?hkM z1T=A@`cCeix9KE6Q`x{Ml!q>0XnQ6>5``41w`NN*=9(k~n!P-g2AzWu`&J&vES-RJ zI!WYNc1_}kcZ!k%9s13$B&aE)o@}*jZOPg3jeDN>wQEQAe+3_{@rS0@*YlhF?@s)c z-dVk%bi)JjNAhL%@m?wTf=J=tqR;m5T%>2&o+i3Hr|y2#D0h^_D|B7Hd7oWncMUm8 z8)A3vJ$H0L0pP;}1f$-7x$>;jnaN$IWu1^|5GH!y+}-cHGk4&}#vNL(q%#=%+*|Yu zYA-g0D1Q4esA+&Bn}E1}PT#Q~>P2nPWjc4SxVxxCOIhK5A|n#Xw>&~69ojctHjj^q z{M5ER3lj=OAma`<1|!#2$u?@UR5w{ZyzXS+RGQii@`Jrnl^t$7X=O_a;QN3g_JoH# zp;Sw1iB;L@{=S8i=Sc20m+1ppaOBV5Nf)^HpjzuVL*7e+Y*iP@b;A@HZ`rTU~2GB%G-SyOlHUFuper_fUH+4a_&Ep)?bDWYyrz6zsCt2`XM0Ug)fKT+rMYrWvXp%-KO``$^vR?b= zWO|k0nL2sU%A#;9u+g1+U=^%)BACgK%;k}K?dCR>$#FIS4+TU57`(R z`@l1;k=reOH(dzuWY$B9xB$Z5x7VnwQeel?u_FqD@NSR^ekhgZF7Y|x^8&v2+2b_H zraY_mqL;jfTPRe{WKAV;b>!3+4$<}0ofs}H1cPlc`QjsLU8<@{F1uM;{MK{va8%zb zS3T4s^AdGIi^oRTf?hG6V*IJm>%}=|vR;TjC;f-{xSkz~r!KS9HfwFW$yxuHYOJ zEI$sv61SRv=po8ua2_9j&#S~-4+{;`7%@f2)?&|MlpPPhGm7a-YnDh2=&l}K&TtO=$YV5eC5U{wcm1HqSeu#nt)TZ>f~ ziOa%>r+Mh^w#@ea$A^qQj%vQYZbx|c@Y2!Ek5XO+3r2;Tj=7<%d8@-$EWc-o5JF~; zhv^N-7IK>GGV0$+XK3}MoA3Oj)omRMbR)Jh*&ezfE$`4TdJdNDpBvMM3jxv4K4K~$ zVWUKNu5Fxaj8yDnWb^!kAv6(KVj526cZDRI(jL~I>-i6wcu&@kmj-JyReU}up_^XL zjn*(ThF9(Bl(E2SE}7GuHRh=r>?C0N(_PO)M);&0McHw3Qvt9o!TKQRD6}Q{AOi}`JN?H60g#@kA8V!DfmuO1lpArbBi5_AZ=LhUI9v zf=xMq6M}Sk!e4JKCj4J-4_KF=Ya}5D)3tx3kQ`^7-hR7(ZHqKEx*V!%l5tj5Gl@)V z6S5DF(#GJ(nqVg%58UlW7Dm<|yy zGw9xE;G!K=0wl^#NXbeDpjp`rqGA1J4{RU}g(k5@-!_@4jS#r*w04OWAJu9>zW4hd zN9P{Tbo>AD&kS>>jF4lLO((Ky&YQw4$I(e{Ih0c;Bc~NMD{8kKCt7QknL~x@rl{0Z zOb4tHB_WeTLNYl--`~~m-@E(vxMe<{>w3RmujkVXTY)wJg~1=rzbfQ|piRa2PrVG^ zbbLGHK9NPr8u8zwJBF?D9~sh<8J?cxbjw)Lo#_QEKV2h$$Wu7zU`1%6>hpyXLg^kNTHuxX)j=6p`&?QfM{xD?545jws-N$sRaJ+j_oQ zZ(q72nCCiuuN2O;$A=+RUZf$$Yt)y~fq-TEAuZs}079&je|yImNPN6J=n4L^?!eAZ z&)1C)&MfL0iJQ!2uI3shmnS*-J?Ng|Uo-ug?-FjYG!z$iIP77W1nJH9fvVh*M6LHuwA0EnM~W{m$nH@MnV) zSmR`_Y1MY!600DXaKAC}jB6loQ~m0^(XETaT4950x9%~|+!;xg=?GL4$p7)DzP?P= zNySTtL>E=cWN?$OhW5XzyMZS}Z5bs!&D&|&yrH69_TR_px`cAMh)b_Oy{NHGN0EQB z$I@=@w7zX-qwvCzP4++}x2<;v*Ak`X49jnabIy0=-TwehA=nFA$3u^&?#i3&_cMw- zlY2U(JB)@?IeXM{$5_-iTR;1|J78vpvEBg(5&~rir-vB17b73S*@^9t)qW;aQ}F{D%T&%+cjAcm8{yFg-usFfE!Qfi5(AUmEMKx)pR9jw;r1HI>7g&lZ2=hv`uo4Q z+5DZS6e`KPTK5$Dv$aBUJi7jsY1opyin`JrgGDrQ6>g-ScGW9ZmqWz)d8fzX+xHHg zl3m00kwJbc$TF0o)*r!khIwpB>HyZbL=A5wZ2ExmL+^)23CuJ}=^dKyky+WWceqsx zUxpIgHR_x%PPIix=0=MN9IQ{>D1qb_B$Npz>aKQTfO!KX!#W=s^=NdO5(=i!%#{ML z8PV34&GG|l(ZDQ`oWTS&gU$k^?@>N&?0*ol%k~sqQufwqcJNPqvinGH&3Rvs@dLG= zPlJ)L&@&lr&~B{f(230aBvV99o^aEd@F!5oo}YSdbm@~c*$LppYe$Vf68^Ko&FOjb ze^Q%Dg|U3Hx4zUN5wem43ugHGCSumSIQ<@mO^rvtk>-{Wr&5`#?yJodX!EIW~% zoXLnU9$@4hP{@b@1{5?Pjq~iZCoOR0I+1Gz3hc!rKE}YSOP_S>pkM(=uOT>*2Y{9!NRKU>Y37%KFJUMp<3_<{0`lgTW=nk(5DuOQ zT|hMFa(Qe~N+cKlEqZ<7Tik+tIr3FTsC~A@AtY*)2_Rk#m1xD*IQNw*0ofCyVjJh? z5IH&Nj;k>lVFjiwk1v##Z3BodzfPi^lneN2?Li7${dc(eYIkiA$d86`!G}g4&<)y_ zePCc7HBdAOE+^`y)$&>I*nnIfh9v0)bwi1KqiPH&xKf`=eUi$!xm>Y?wTB>IKxVhHmgoOQMsOY$iO6&eeYLGNa0?LSFiEZSzyEtFOJWS{f(S=%$RA zlUat=IOQila9Udqo0D~9c+lygh2fe*xP{#@N8ndkE?%4pK=1qS%VgU9@m=IK>82{F z6$LAkK7OV?j7oVeSA@8vfFX~_Bg&a$;<<7ly+2z@g&csFE|Cja`3P|~Q^6yl zWj)@Wnp(&Gb2gNEZ~YN)2?bm`&T-}yjcLD6A<&FR-U8J&ZEm$r#%eQW$OzHgD ze|W{5_mmv%=g{M7)br4(a2vS=7Iv+unR4X8or+N$R$eQuNK#vHf?5O1wpTS zcI7Ng1)sSCQ1G~A5O_*FbmZ8wE8-_NBKL8H>~=3(f3?J2Uw%sJDQ`Jz-x~K3u7?kcgerIFW0<*6g6N?`diH*m5#&*7_C*Sm!h!MD;ojfwew=_lw8j zX2KMUvEOZ~mi9j+o7fD!NP+Gf^|626oVP1mvqIKQc$Z&%PV+9q!1*S8uEgXH*BFT-}ely=C;0tK4rGJp*ifSABdBaM0(RxJQyqE=Ty7w1z|Leo*7 zCtc%k5O`vEp^U({6Jf(;sRw~NCFF~@|C`VjrzcIh0C2T^JdY2)SpzCSiz4EH5*}!q zzyR9QC;)O&a$TRB6X4sEMM43*3*9}t-i&whj>9+W!}oJD(ov>;OmV}@mfe$H4rnyv z`5HH(-xPsN{1R;XEC2=MWetaV;0!gOPe`{4xCdKBfdV`jwu?c2Mye7arpX};>wVdw zwV#92m7R0KuR(#{l7Dhu+I89;)_xspj8pHP`=iw|k~my0Ku`7}Gx=!q+UPSjqm>BF z96zFsW4Bm6gps6!=%K1)1L|skyj43I1f3upCHRm3Y$rzKYKcOCeTC$TfWusEaERgp z9`}tG4v{bk-K)ck;&Z!UnbMW9F8iqzq8e}|$gk_O36&o&+n=q{?3RLSMpT>DyTx7G z>yt9%g=^%~+Q`eS<`23_@J)};WM19tnS9oD*R7Wo-5k)Vq#2A)>~r;UMZKEAJO9BX zjM94lcBRl`hD;I=TEqeKG=7*i0W3-McBBtD*o)qE@pXTJzeQ*gKLrx@GV_=li(Jt9 z63P4;rn$cYBO~~ydLWkm1lmn9NaPbaaLEJIyP@e;xOSu*Xy{6sblU;g3`9co?9P@JfC59! z!Pe!b>70;LTbWOfU@jh-Qq7}J{^MR_I_&;G=(1{;3xlg8h7mF`VAwc_FcC)_ICN8YSBOsO`XCnknPz`}?*k&E zgy6xqN^_*xlqx{GHmqIu^0R?p?U5jpnF|MumbC)BFHzuX$FDgJ{C`a^Tl>}U^$tS$ zrp`0}w*E27rTv-@%o%ny5U|B*A<2KVapnj(i z6Xhn(h2`+K2LXtk(_e@kDs$m@{3;ka)vTPzT>QuQjGEUqr>!r@^ZR#x%8rBy`>uD^ z!)YyBcTh*VQmWGQysIHu5IN2|M^Xp!!ax#uWuq&z-?zfoo#k_q4U z4U}@0_4dpV0iq5v`Near;|=6Irvk-G**g$|@Bp!gHT(KN`x1`=g} z1a3Gx0Cc!Z$xkICrOH?SQh8 z`oKQ++Ux7S^``|mN93K@?K7L^ZFq@^V=oeV7oLN>PpQOVG zndpe~GPnY{KgkeAGfn0ved2YEE)sP!Y|3Q{eLfhRQwqX2n>sRKImKZPYKP;IOV`JTx=Z(-&QceN z))_{&P4%$UB4s10VdRg1YQ8D5vl#K!E;$eDDYh$O$tCR z!&!3-1Tr22@dmQQdNy1{MAPnP08H=Ahh%^Ix<-NvZMGbe4UXJ0v>A672<_Od#?0IR zJ|1W?gGl--NdOflBe0?V?b~i1ByFOIVBI216o^mga_9Q!?kq60h_-g;0Jgi7n+1@{ z%OVI&sg%GG_ZklarWH^bFy#q>pAuq1*84=WK#9c#pGcsCK1Fs~+bF)X^grk-xZ&b= z_QwV8etF-uC?aR+dzuuOmNvDj?_48A&h_?Pr{QWWa{{7d8RV0z=!zAFtmTgv2w?C_ zZb9ofkUbHOQs{BUkjuHF)RIK{_ojbyR+4YOoE449H1WPHnLpPac>6zSc@4m#GY~}8 z9qG*B+<34ibR&B8lf=Qt7O(AI4D&y_oRIfyBY;^^*JSLJI^O4mUrxT%KxAZF93S6*83Jni1HmGLHo?4jSFWewi|#A z)hj-Dn=&A4{02J6VBwVUWu;UD4$w;1-H<~H0(}KY^;R$l!({S7jDDUk)F=5);c9@k zz)XTvV~bSKst6rG`Zpf?@s|(2XCFiU!Z;ehSdeff(DP`4a*G|RT;Lq5zsT}MF<=1K zgHzVzeAy(3_GFKQ>yO>Mwg0BYbXHDuM^&!iH%Xtv)Y~)2%D=$3DZ?ZVQ&q;q^Z~jn zctR+48dNzl%W2|Vy;7=GyV2{cv7L<@7RtEUs21aOHuhrna+eDbqbak%PA0Vu@^u$} z0hKv9;a4{as80YoE;!bN7AyA^AlCqTzTTHV8wO6^dr*&%`|w!30`Os`+LO(*YoGQG zqkVS2g4UpxW79~{hpxTZeUuWBnmJcd;@56%5l45{hzD^eS_|qZo`^M-FNR3TTzbv~ z?svE0dawa@{9#ZvQYb`6K1R$tC$qsPwF?lg22xi@p;Wi@eXX7SPrd7WXF zX4V*Th^unU2mZW(&I*Fs?3eXIPD2I=KjLnySCZu}*ieSe>AHF268>I-F{~Lg)nGiF zt67k-~ZYiRLkzSSS3J??MPS#_cg1Im>p=?cD6n{j3S{ z*c_tZxL6^xE5j_tDF7FLFKN>6(^bajjI>8?^HqqPnKg{-1bz7X!x<;?-6UjP**I40 zEi6PX=%F_D2_-!?gTYo)o1FNEybV5;G#%e&opt-~cxveNv@gAFk|5urqtiSlL+h9N z&$e>j?rDx?M@&~4byRrkjL-BOKDavGDXqmUHNfr9`7!U;40G3_lsPwz7Y2Ikx+{+5R2iUP9Pbx6R81GDwiW=i^o{r0T7HU zvZa71wRbhLX~Oz1VniJi|1A=hT9?_E1yCd^v+di1>Nwq@pl8mW-RG8yg21~p6W|A- z@N6mbiH}SyI=O68T=WCrvCICDAk&&I21^8hKXHyzih z_58et(d@Q+-|c$<)+Q4E_K*Y&PC&*@*FLXhXWJI-^g|bhR2ItDT5+ts%pI9sSt^WR z3>$DpA>1;FP14W$ErujDn?L?B+%=>4qU*ALYP|%`Kez5hy7xtYipQXsYCG$if*Q*b z5xCrT;C+vx`k?Lf>{6m&s^2p2-%z*Xg)HkWJ@?HtKC2~V@+=$XNt?$umnp|@V6W7? zn6Hvq)5SUwR)Hy#aLe-pDsyf0eZcPrCFgaK8F;Fx*>+{tW8zz}d_-?H8rHvJSrl>k zc$Q{n{h7BrN@i>SnV7HDUX0(?xemw8vb6<6{Kh|pQyYp+Tv02ivR_CfdRde*VdqSu0gDP9_ zidyt7X$9CX2xxy?)uRD4iz?|znY3!v$=MTtd%vD~AS^qRbxkD`bk8P)&`4J_QN{*C zcaYmoQ4}I;WWutO0hPyP9ZccXBwjK}r1*BA8uXebZ1~6nWr}PTO29YlRzdM6+Dd7P zY+p_?_uU}436xE^rc{F26^88Y1|SFDh;m3s)4k_ve(t5Q!r*lGLqi*`hJ6S2lmjy(v%(I6(>n6M5qZ3{Te>G%aM3C%yZKBWKIm+a03z zTzPs8jKfCR$dNfu7(v#kT6QfA39bB;M_`7}h2C7s>?!w06o|+k@`i`P%os(Z#$*~N z@>79u%u5M^)K|;;Na-*)si+f=(hS8)|_aF~vY% zwDHC&MqeaH3 zY~|}iTDqo{+}v2p9Z{O}d`tC!6WBQ>`xr$Gd!fwP(KyN}gZ<>Ft{1W8z_hkpM}O?8 z0}9r>>Q2HgiwvIMll_@y8};?>lN?G?k&+L}W`={NF0#LGiS-W5Ax5#+4w{TTh#GHE zj_*f6ekE_#Yz~Rb#$%`_32)a~d~*M8+nYFa!h6&D#!R~#{^x=T@u zgRXxua}n`kk_xZ=wUIgpodHQT;51Qec!+9) zN8t9{SHJ*W5?>saR|~>a-aR?bvsZjzxCL(3I~oTCivo|Y5zy*m$KmaPD%1$b$iOcS z)QLPsA-kfc#8f4;&2&^Gv?-qs(qyO>8BlbYAfhYgK!A8%{U+5-;LkSXo)fdY$8d^& z&rVMNeaFvi241%Q-i?xKz5hXn{;S)kW8by@za5#%-Q;c&B0ty8PdP3tb!X%D3-#lv zzpmMUh030^4bjX;o2nGwvf}$zgF{wPX6>fcn^L^U2Ml|@Bqbd?x{%Ab%rmVt7RkC{ z=;RUULPcJ4xrY0Q53Iwc_UK}?VDUIJO=W83VzRut{=w>%9Zs`eZzg|bfXCi}VuO3! zm?)H_C(l^|s9%v>IbbB zuSAY4@VHzbm}^R;LnX+=J0qe4&^E$)XdBourl7bQ5d}Cd`yJj{3>15CFgBn%nYe;^ ztX;4#_{z)TVAQRLC+0Q>#~q+3Wqc1e9?0O+2vV+?4f9+MExYH)7P%lC>zaTu<;HA_ zz9^+-dvve~uaB|Ay2W^>mAHrnD%6yom(Vb9^G*Sdu38;%Jp}mnf~SBl!_U3j2Mko7 z5p4if3|fQZ)mCqlN5LYw@4#wc&tJQoqW%A%VTWnC>fF;Y$3vFYM^1DqNbL{eCCY;j zk{A=suX)KQq(OfZDO-hnV~wo53H(tC-~hQfqp8$zW{hpzK6|o-MOowt=X@+2DM%f@ogSMKIoK?CRkp=e{}{_p z6qXYJ?Hb8WFKM8X2dkBu59WG{*^n_ghZG6hvr-mE^E}x1;Z0n(-zDhB3nXMONEU{H z`YbNlY<7Ybi{9dH76I1!1l>tipscR!u>_1@@BV)4eDw)jpAIe0HBrNPZo*6Di9rPh zdam=-W|)oZG~Y@>m}4QshH{mw_8NpvIEL!02AOZ*lN4+qBgz%sHrOk{1R?BGTNn%S z-{^H%Q8>9rKNxr|(K`2Vir~9TzHqw36T)irPg|_3G%XgMqX0){I8~jmJ4#IgSWsMPK2@78 zX6(tShIAHq6L@`kAH9#NJ_h1gOt9BjiEJyI!YSuah-e!w^v=zj5A0YyfZ+!Ck8Y5X z-7Fsbzm#IX?$2y!$Nk!sAM;D}Angewjep1hHO1Iwx^u;;jHtG{>)q44z}f5eBQ29} zo=^yNE+lUMxw8Q;&lG9fB&QlBCAVt#5dH^!zV@tYXM6M`_5jqRm&&}nvF_HUkQiml zPy*IeKW1~6;?A!|nm=}a3hT5~UsbGBUh6VTT#Y%_H3e*Sf0w}ZMlD{P@FEcD``hvD zPzI+!%tM_r>+Y`M8<+nF9j@r#4h#(|7JuPUZo+F?BWeC5C)Zjd6?}8cCNDBuDI~5> zvUu@}@Jnrw^| zYklI@VrHZny(R0;6+5ltHnN%=)noU<@W6u(tN0;bkpCo(;HvH+)-0ekmtS6IxYCuK zTGu5QrGD-V2uAxpbU-T#gqX*7QRenOa!nTA<_GGEe*b4`)O;~T$7b|t^yOcc!O1}< z09MdlC06}Wn@%ctKhG}tf};}VwaTok6&_^h0NH7#=PFGxhhj%!;g@|ZHv!xen6)d} zlHl3hpflmvP4NW}5gA|wHMqxcDwNG612`0TLRz;&;9>~kcMAZx)Gr3HJ2&t#$r348 zwIeefs$3&=RDwkgmgU}vD^8@C(Jj6 z*LhPUkZ`ZYbbSc9Bxv8w$2;qXAuo{Tm&JM>A#9}`R&HRj4b8M83@RrG1gQ-x=29^dI;dw8(#^^j9~>t1O?ZquLn8DSVsMR3PKaKPvC(F zCAXp=pF<#;+|dte2ECZ){X;;$ihH(A-dmhYZ#K^YBsPXT9$Nn6FGx^##&Xd>_ce5r z_G-v4$E%JSy3Idpm|4@+Jj#LD&${2uFdG6Tp1pWZa>avIIKr?sck^iptLX$UdR^|n zm$sDW+vn%p$%UXWeAfVE}{H`G0o#qyC6m5=`#4; zJ@SJM;7&HYB4+{VX9MN8E8(O_`1bhv``|zAePekNK)%`jOUG1#eZJk|7BDDURzqr@ zkmY6>9c{r>x8FOl+XxhOS#vBwLKn)@w0qm^)xb8-0{S4{aHKl=^)CI(`!5+-+Km0I z^$(IuenuC0*7C?q*E3z~@bQLxtSP`$~wo$W9DYo)4g; zV7WNXd&Wl_0QUPbP~v7y(5le3q*{x`Qm5flk!1EKKq+l)^2v6% z{pKk;>*xo|8Rb+kP3q;UI|_AMFl^19BC^l{Z6_koCtTH%F;CQ(nxNo{$$rX&<+T_* zjw84Siew71(T%UT9P5Exz#k^Lc?{=DCDmxzdE_;_N1;@eV{=PBlmu=@E0|_QNN~#8 z>c0EfYG|D7EFs1l1Kn~An>e~RGIr^aT8a5TJ+pvoD{whKT`>wbx^ixiJ~DTHW4YBg zW923CDheLwbP?+pgDSUUq!GPP?FNxrFS10SN5ND}=0>Uq1fi{Q+>kEwdVL?adeks2 za8Gk-&U1!5@&?!eR!T66)Y05AOkDyOhvGf(+z8js0oO&0N`N|s=>sF8z|svuVAPmo zfUnl3Ex#)XZ~(V)-*ltiS!iKr+6!hkTaNDlC7LVwiSvZiFmRAFY5tIMIs zfdqwVi$*P#vfU1ZGE*@#Tbilwp9L)FHaxnZ%m$#6%CH7iK)`j91Sio5>U@+|qYNl= zPQH`2Y(%xqupm{WnjAvPg-G*A>Mt%C6jsP?6L_RR9T`raVA%P<1~EQ1JbSRcsolMp zb3W)--&>=rW?NpYmOBkO1xRDl0%nhD1+6|j`Z({1g+3rl>ZcK}ZVJ_$qcHX`)Ij*v zpKkLFtq?PkfNY#%g@m=h5!`m4wOMg3D8Y!IZ3O1=y(|&Py8o~xV@FR0L z#Ao5Af~~AM_}JoWJfcf=OQkQDS5f^DGM2QT8c8imzs`RWuCcxUbxg- zc=#q~T8BCE_*ULLwl?bGuDz95B^khrj7+sep%g~oxQSQ%@*Ua_XmgKrJ~>vZIxl;1 z{s*PL2CeRsy(<r*l+=H3d9mE{VFG}H zr*PkcpV7}A?AZD_?Q`C}z7{%oc9v6mL8VMOT2Si@$lsBLkHC2}W{aYnK!_(QVg=*2-7atL znmAebNBFgMa?51Dx{BX|vg*`y*nV)H$w@e3s#Aru+Xf5v_Ciy;Rled|qXumq)x85w z%=mD#!um=^HywOxQ-(M^^lEGAqlT-8L$mILtc#O-Wp1v!eDHKpLWiUK@EIOG$Vs18 zgow0Rav{8{8Uu|hpvMhfdvp9-nqJb$EHG5jeErt>G0N~tc45f&ZTr&_6SpP&O5kog zr|pWi4zhpLaVyLDX#aNZociMX_r3GSJXW8kCfSb}6=T%KZprgM2OTl`cPI1onTKkh zcz&xEuaiFQcWsW;S4)kYUAe?P=wJ@k2g$&BwHR!#{jvl%C^>LY7zef7k(?y|Y}Ehb zuQH83kwq6eMyLn-XM34-N~^kr2deMtI@}1 zQ*)>4+BX0I(|V(?ENIZd&PQD<`{|~4pP-}0owx4(DYTt@*9u6SW$1IPl=x8}8a1n{6xw8XB_Hj4`u+~6EwU&#w6drXQ>9Ik4tDpE&KRT#&a4Vl3 z@wI5Fc2R_2aoAmnFz=9`Ly6@YIIagUrFZeSpCqMX6s$U2OoW)>q>--FCn6cGAwPnt zjyZC=$(jb-AP}A-l}Y%;^Sq|VuelL;j~#vkS=Ew>@do%uUM>eicLH^@)w427`z^QafoRAJTQC;gY9SC zu)lai<|<~e{w~3@@W>>`7-%zl>BzQI|v7FpW|wTWk=2sJP{Z< zI)?PCtR1d$?p=1|GWddy%#tR%tost=`1K-h9;)9Z-V07Sping z5YUl6e&-QvjklR}FJK%!8X&7L9xhn&u{fmhxyIk}R>V`=_Y=LA4EHxPY=0xvryh2gA{=X7c5P_&Y-`yxp?b0imBSqiFATsh!E2lr(; zgDOkR6ZQ^_pd6F-XzAE2bJDY2liWKH%9V1V;|BScST&a|49dVU4q=XhD3)MQvU2s4QTQ{mo z2S@^?|KK-n3*i{3zwp$HN{4o@EJkADcc@Z!qyLSMXR5t*V2L5_hO1H3-jZ|2HX*uL z&g;lw?1$KP;)l(zrGM6V`Hn))uxu=ndd2>}rMnY&0l78@*+q!UO?)&oIUlqR-P>aQ z7?K(?p%J$r2h`z1yNrdcO_%{5lt}i7tyghRCsTc@Qd%|UHPy! zA-TYPgX_!t_it+oS}n{~xT>#{g#n1zkZtm6`{O#Blyr+PhLT@t>F9X!-6b^^@je>J zaN~IiLylbPoOJ=7*NXn9`J~oF+X%x?!$Z4OVUpuw7vTckb(m$yNJyRx=ymqf`bie? zyZDr5!^OA~ZY_$jGfHMH((wJ{k4c_3k}Sj~#al zzx<55GsOO2sin@dtcdrA(yW3U4^1y+yM1-G0#m6T1o$H^qGjQknUgzAXxr10BV1Aqs>?u5%?!QcDNOLk{Uv0hkCEx8l z;bx*0b}5=VRau(7B7)&{0C)}i_cuQ!a#MCUR3YVIt^v6>z{8gz<^YaB7J;c7d=8X@ z21&enq$Z%3BzLy#cRW!1Vf?u6^3-1{b@bc}Et$EJsNyc-p;ick4KR^Y*~RI??Kf;IH3DsB9i9Z zSzcnSHBO%JsugYB@LNRa4A_AHkUMLJ!<;uZBp-dzjf_)L(D@TTc~ogs^=6P;KC%Dw z%KJ1yZ{826g_8L^DsfZQ8j1Wa{pD#RG1X!7Bn|@tY^@h3=6TpMo?)E|FfxB}F99NX znNW3ck&OY`mK09iQ`v6rP_-jcnW4HZ3aI`f<b=&n{k_TrGzs{(Dx`9 zrX1k?15mclfYuRcpaM4@uSa-#%><=3+`XS`%Zkn2DOb1ly}&eg%iE~*7G9}sko zc_E@kx*m*XZHsk73alPi&3N092UzP8jU|2ToBs*z#Skne)@E4@?=*;NQTThhgjy*+ z5M@pOJpW%~4y@dKU}KKKt>+daU;-%Zl<8ZtUBk}O9SJwW|IF#u`-X38i5Pz{c|;IEv|p1LZcpnH z=k41uGBUR$k~#k=$FYBbYt`|&(Xo{64;|vLhk0L%!|dbBWx2Pmyl^bWe6QIfqu%Ye zPOi~Doc2a5s0jrn%;~!O)_Vtv3(aD&LD#rd`#W6SqW34{xgT$vMnmI25Do-v3xV;N zd=<(G$|$~)kMn)l3r1AiO`3`HsM43E$z%8Yxu5x6zT;X@l2R8*5mFEO_e(#aG?>piVM#zi~EJ~R|MiJJ(i$c&4fPeB%n zyU>c#iRjBlVd%PCggQlG0o0Z{qoF;5+D)^%>ch&tosJj5NFZYM8?f{`yGo z#L(U5VQPbT-&%Qjv=Y^taUi%6ikDW>Z1g#i1}#GzRZ7H*3!ln98y$Z3%Qq+-sU8+o z@?(l18VilP*7+yBPT_khvtc-w?CL3}%&Hz4F>IBv^wTHjDDChKs#RBtiSvArVoR$%u{9hq4g-tA+=538Mf91UptdZe(W>_ zX`ov>RyIEf`CU!g53<`DgKZ3{S6mBnZSwgNr5e}sO(c2gXU*;NJ4xObmmihnkG{+N z{nqJM!2BZ*A4Im(i&M$g7igKkcjQd^kNhyY6n1p+$JRfSz~Me6^+BY&f7wdekQlYw z%^>0CnXjylCtcgWGuJ=1yM$!Jx18jbc;p>*4Q;5sT=n?Hng@1>8GstpOT!4K*3kJ5i0Re%4d59&W> z3FgdmPm60LUoLQyt})4vK4*TbSoT5OTL3%=7JkW3Pdg{tPDEZ5so081v>6nk^pNruR6e{4$rPTJAo67VR)dT(E+xAW~4Plln!^xCM!3} z(EyvWRwT0t#RVJ1J^R2HlLdqIzbGPOkwaA^QV^7acJMUtHfK08Rcz1lrDf(|jSd4i zKjR_sERJ3eF;MzqozkknnvD*Y$+y#Q|5I!6`H|i=lhT{InBw^gO+s=@xKHK;m`?;* z+A%ElB5zC}keU-Xy$WtCp1&-Lb2*!DPzm2en{p)+iQDr4^ zf*7S137Lwo7F13W)uV$E(mPWLbKe6teidLhuRpcSLCjUFuzL+=)ubntv}M^c?HLNWw6CjN=^;IW#Xza#jgrlQg`n+U-n1RAK4z2zaTbDPX>| zl?kw;Y)8K-oRYe}l24+_S`l*LI-{!L5RHz`uf>=%F7W|E;3Of9L7fUI+?Mhu!46euLQ49~-paPul6k_tj^!CRVggM$96;UR?4mnQaA}z#PcJ@&E8O#!=O-!kOAc#yqoPs%$QeoNGT8zCi$bi2XN`E;{VO5~O@t=54R5&StP zj+Qsbx7Z{w#2ulDd3OKGs2fTJ%DEq*A;Wr$9aEu7tBRw!*v%sSA4$V>s)8x} zft<0-oiXFJ5PyB1jZgAQr8~`+iknAjV=cVm`if;NJN1qD4u`G^1m;!c8U!6<4I6!i z%RyHaq{in;nV82gvxvc-g5)jks`*wuIo3L)V&6gJ@Xb$OEi7%yWKWo^E!Yz={Fe)ETi zkf9JeOx^f;ddd5XukB-0GgLc{u8986@e7CER|vPgr!&^g3WoBrBU1bBD@u>j`Iq4j z{|D6+=dBCgBj@llYN`nlmc0X9DV>$K`v{gL7`apZQ_Fec!aZ%uVP**%3gH`uBqcLy zQBc=Us}W5wMlHqNSywRb>9T8RQQs(|vX|M?{bqmm4{zxZSWA9#J;EN#4N1O5X{5VOwdP(77yN!&euLTP zoF1w1{Dt|MuO3)9V$xGKi|WX{)flvn4kAJu%+5;37%<}qeQ_=l1jRF_**=iE!RGgl zhAK(q%im6~UsC$XeHr7nbJ7qBObSthwpy3;6r0}S0clfc0ZPq|^lQSM4!AlKZsL4^ zv%w*%w;JsMiG%=ezJaaC0ferQ;Ebwi$mGto8&o2CiV?M7$7B?Z0E@qYB21s}d>Nsx zi(wa@ot{pA5ZP`7rngX-sMmZ}Yxkn_(ER2tr@*QowtC|B_-6KOcWMMZ9zs~$8Y}=P zjuV{K33+GfO5{oP4%YfCINsRX29zZ@bvM$MyV(Uj1u(o&mZ2!bv(()1_}`5VkvQXj zUT`+wSv)(uUHen*LS8Q*Lf81H?QpUfKd)t8I6Q?J3E_WQN(Z4DhkjDlXl|VNDvjH! zDtnB?VUtp#vg9c~xEWXLeSNw4YqP?0#&BcRR#YKHRX?H{UW-vg;NAO4!&#vIMp6n4 z7J=Lm-ensKu$G7Ob8d2>)yU3hz&r&e78g(`1rG4E8|K74;OT=*;QFAcD&WlSC#Gfj zz!(7@v#o!fiRncExnBo`=YlB|e!c}*O>(M@Cvi$@7MpJtr)KU%Pk82@zWlUsOJv6e zmKz^CJCG}RdSaJPCd&gbpywfTj3JwpN9)O*?X8CIq=CY;cWZXN7zawmokZ3Dmoc8@ zO3PrJx`a{sqK_&lQk~^-ZlF>2(&1tlD3uR`#TwW!{F^d5x$pG)4LSlRzgK@kn_NCv zTy=n6)hhLFSDmhnkBQya_SW&*Q0gJ>)d+1fH7s9NvmHavW|JT}$c{cqQ25*~J9WD5 z8U!dr4Q8>{US^3l<=KQ5J6U*c905V5XL~~WaeaBQ2;}1iK`WZdvzh2A5lpsV!XWY3 z09D`WgBWWP>tyd2bI6G3v)*w)3RM#Hv(zc<9T%}7?YMnb^T?rMQfskVe{!>NVgdwVAba=3TMICx~OCoyY>B3JFB zG^HjroJ$InoYMB+Q{A$o;j}7b}F<2^kcFb`wvN~jYINZ{?X;` zrF~X};up$Kea^>s#!V6qX}!WaevaCsqV^2bJ|9Q+DeCeS0N^6u0pNObt(y&0O%i;m zF^a=fgVDm2idwQ~|HbR0XHJT-;V%*m;`+*9{=pLLH#9Wzh8oLNd(JtirZBm3YwNcP z`<(N$EXs~E&7ED9h9xm?S zj>LFNJl~l77DUuGlt1X{dpY7Gd-GDD{;s65%RfF}p2*^$l`92GgbG=N$`1E$Rs_X; zuNv8#u#)UL)6-va-X;l#x{u$8*-aMb{Zshyjk;H)Ox#*}-IvF-NiX!h!(MoEc-HLYB59HyADMhG<4DOB_(DTW3SRjk{7NsDEfHpWPL)R z0qpB7Q%&pG$A|u4U>_E>HMZ9rQ_?zM{EP%b-T{vvN$h2FMh4oxksJNjI>5lJ?K@DL zh@R-l8B}sZX!r%dGnInIKhj8CfaSMC`@4_6={j9f{^1bFPL@9j4cw;Xj_BGsxhz?t z7|hYLoCjY&x$-%dQZS9aoNHU?Bh;zv7{UrgexKh!-gqJMqd(hHu*`BceHAXK*oHHf zb_PU+s)zKk-1mnjbLCDoHR?`!qN$+D3cu@@CyWLTM+qoTH8;RH?4hl< z1tnh>gGVBm`#=%PNeQxxFDpyN%fud$om|nI3{zQm^_6O0lGU=C5!=C?aR`WGne4L>++EqSE(wb@Ef#6 zF&R`Q5HeS3I7M)-u1f$E1XY7^3?QyrPwc~&aS^_(JpvxcOZ?)?=W^_TSL+=cBq7K+ zb;gfFH`zJ`b z7vjsDh=Hkfg}ZdF4bvBWg+zz{2&zG3Au_>GdY1R}L|L9U@V12Y0?>pqNKZsAi)_V^ zaLiQ|yqTf1yxM5zWd4)~+)&CMzRF6TA$Yu=H5mJVS^sJ-UE|i=il^XD{Fk4O6FO|p ziEc;JAY|9pDcI=2ErTxlspU@^FOO9ODC!+r$@5!p*uUu~_byy-Xx*$tP(8)6fPff`XDUji1>+06nES zUBX8%HApbst;zQ1x-T*{tUO>z28#S+r*7tW4PWOxne$qId91KZhTAsg^abD7WYg}D z_OE_ePo8&sIw%RQr{}{uDM1ug>bp-B^{z({C6D{4&{uB)cdo#n;#r}#QBuy{a;vp2l-}W<> zJ6jSE=`pg_vCdd&Wp+FYW@21p{i%m#ut07zxT3Poc+9+qrRije)t$hpcYsQMQJ;-4 zsJkT)e1=87{~k-RnesqfUBb7Si7zea=TRwscw?%kjs8Wu%mCqDs2akur#dlNxIj7cWk0Zyd8Subd=g0C`-<0GP{Bh0gHjZA(7rn=y`A29 zhLSLR%}i5T2LDVDo}O29?RPx=B#xvVAuvgQ=uJ7W|8D*SBR42>`+`MQ}l)xMn|GzF5B3&w$`I`452va+$s z2IzOUjZJUf1=z&{~`)hZ=rih&x!Pfb< z9Hy$Z$WORyOS9(_$zZzE4NuUBs9~zNk8OVnYCxtzXBwB9;r;qzgb6Y4m0?}_7(YiZ z@&dKjqil9=@8FjM2VeGCr@dLhEn8Zo`34b=t2lEqpQ8VHfABQHAw~}FK-<}l?tE3* z2fX6{6s<%*9}H+*+7@zV;TV{Bzub4))UmOxN?DuK{D>k#+*!>3;`Bwo$>jZ0kC+rf zElTAON1?^~?eV}fW`>^{cIt-0Hr`bnE-oG;-66F0;RLnzCB*PAf+=FZ3Z(Eoa*a;l zZqtGpaY-HL+0C*g{Fq%+)WsjRSuC9FcE?iI#|pKkICoUXIUl&cKAp4q!;0bK^P4MZ zf)C!KZ%+s{(ycnq9ZV@r8hzm@-g=V%up#`S%zxXu3YNNLDH=Sd>R9r5=XXXKzllb_ zc%46Yo_1Qln2J;XzmCp5p6UL7l&z7gq{>SvO+2Ee{+3@i|5ozteM7gW zTImXN$T+(&=GSpqSSY{0lq%0ax!bJ17euqO?F1$ehWf7SPf(%a zg}~Z;!N*^#Gt^QVGhvHs_2*w#lvg^2A7D*p6gSFrLq_6%ZFy8)51#Qt6Q>7@M49L~ zIgs#s#NP%To(Z?>Bsxe8m-XRJKLJDwk(b!bCaRGR}WuQD;DFvc8?oc{Nf`WVu=v_Z^3L1fH5m5-v6&zy`21fGbv}i|0L>EuX zb`-=!BuE`w>fukLVS#MqZk@zZAIRj4P;{ft=$S-TzUJ4&ss~UMyR<_t74moZ2kmI* zGdP_W#Rr=}PcFI#orb1cuD3k5qBq~Uvtem5{)?mBfDR!M8V8={;;Q>*wj^GkswjfpM6?hSg5KZK)yddx4N78Is@t7Cv?jSoG=-1wd#9!tNOst z+!qNu#^26MIx7(FE8%+O6d1Cl`bMWoF$uykZDJj>^`Ml5DelcSJ{dTEF;R+`yl(r;bScvJ(=0Rm?)6xmW! zc`;aS=;!;9$ccu{7ul3!u~L$1Fq&XvpAB0QcZ|y5uv<>n%kOQV>r?oc7u$lSFrj~W zlePpI`9czhupZlxRS~Z>$4SFphwJ*o=H$!LpNZpCPiCADA`V!yJ0rB<8U$f?gcp?L zfAUi?H(Ws;r)XoCrai_56}X!e(tM<;cT6I1?3JyxrWWrxP0@I)hJQfPb=;vP&(qnX-iOi!CEfo|bv@HE~si&@0Pw^EuqwA^%vzHLZ z7Cf{dr9pl9YPRXh*Og9ImG>O<`%muN5pxqfw@0$S`Vl|J^OWUf#x4rlErnpmU?e z>$$Sr4ez#$D$)EC?l9AJ>eIaWp+!^M`(c&DBL&L}O=!^@rX89q5mVo{PF}{BORw{u zWO8N$TXd7@0{3SQvnTq-h1k^;F-o5O?<%b6vcSU*{b*m0GXXI+YB7XV`B+B`RhTUIw3Ce-=Q*|5l7Gs~*{MN9-^^%S5 z%)!(~Le7axdOe(+9R$;!l+)(T53N`0DTVQCQE&g&CYR^LARD6{+tX%`QLjEV#u!ct zf1zB@X=2qCl^JqA3TDDzq&8QQ(vWqqfjs@|x!Ll%4_{c?V0fCZ7_N%bQ{x!~vY)j= zFj;n{mVZZJx@`}tDxN5Pqa-5f2rS#U)5NH!{njiyGSubPsJ=>@J58z&0Bqj6C{JEQ6-$`PXSmIw!MPNgU3sC#9Z@0^f`ngx9W+XALovb$7*0CBB z`9sK5w8Y7i+-+(U=g0k)XW9F(izP>}v;4cO8;uBAqZ@Cn9@2e0buh#yk$ClXht}ZV z&EqEZqZj1Co+YE({aiP`Y8Y=ld$?(f?t$r?v&vgqn-rbdcZ}{*Zk~Lfyg?>5vA*%! z%p=#LU$cVb1DKbO|2ZzcvAAVIc08EB|9v!bX^DsA)x-2@PDA&%+gtDl-w9^#+Zql^ zX!)-Lv_AyDDEU@n0!~FGE0pkW&8?DasSV!$pX0$d zVdLdkbZPN%mtJZn#_3PfSbc}`ggJokN;1oF>Bv6-#(&8MmcTD|^R{3T1V@72rSU2^{$ixWP3arf4ub4t^L zOmG-ZD=4B=;Ft1X5A=bMI6|d-!w`*`qwW|~qgtv`+$upffAV08(An5yeEVVVu3Tub zdIaQhGJ%CGqsut*%#JW3Lhs`H$j~q(!>h>Sh;>1l>y1E*&lu!WyygOYkxgchQx(re zP$FU>m{{=8kf~*(nj;~|z9cHI2t-PLEQs`xD-{&1e-n>GZLW|EF;Tf04If|qvT)Sx z%xCkiyRBD80@r5er4tVW_2i7rU^O%7s7EH_S6^l{$on_?h-hZ#ZHx?3OC`3 zSd`}9Wj0e1J)jB~061-yJ^~zoE$4gx?Y@%`GgALs!~sHbW%GCGZ^f6M{OMwK6Q9~q?|77M;qrdwHYi)`X%9cOxX`?P-lA^HSh+_|X?VMU5>f z4SON;gl0Vq=ymm*>EXu$JLm`{s1_bYpn{Gy9J|B zy@e~UlAR!?EVrG{rr*1b>--(EG1X|3iY^}7YbXYfbr{GN)fkh{(6C(O8K+Gq5R!(CnaS#CPFQs3(IG0#eKk%uAy0P-;wRSMZ+u35R7Y*pGKiZK1?>Ig2LB+dj()~WtT-&8X(J@I1 zBt6>DnoUhhex%gbC@w7S=y}JT1ZnrxCC)ubs)Ue+m9*e9Q;lXZAGD}KR6wR%*-hIt z2cSn~n8Xmi#B1%btTx5nT)pm4?jZ7;DOaAJlV-;xWKw`0h)^(PE*)_#>eyQ3^phth z7fcVSKj|5l7iiC3I*A(f`nB%!j==Q((82E#4Xjg^OBK?fdWCF1>SvyDk2LD1@%HNy zq9lHWz1NbLcuW-aE8!D`;U7FLCSkH_m1088*YSG;R(6Xbp4uL9*O3KeF9eKf|~54fhR-q z&plG9u37vlrwZP}zkA1D*CLsF$|p-#t&8h7h>a|>v{VR?3+cNOf@e=^t3zo^C%1K@cXVz-Z2h&Mbe&_bHIC>3x|Vva!SwtdE!yG6|VSm4)N zLYVGr=Yb2&rWzjoJ&Zm82id;~Bzu)b=$HOE2=N-*3_~@1ayl3*Tn)Bav-!yO21CBK zYtVL=$fe7m=X8_wy%so?1Vw#=eV2y6a~#ox2$wu1|ie{fn9=NYb7P+}H8IlmjN6j%*i98)9 z>WyAMy(wW3cXq%qjqq<`FK->p#xo|o)clFHs)*^g1j#b{Mq~w-?UgV>P5oN3EZi<( zzwCd=OQ$n*rB&ISV1&D;c-|`iM1G2K^4IHc=3sFcRI7FhEpQmfz1o|xxXWF`|FgRp znGnOB7H*FN{urnbJ5wRjk>J=yS=wER3+GdCj1;RtAI#$*0+>u3#F+9q1_m@LJgvL{ zE<+pkn#7`U_e}t^$ZE;2-ey^$plIO9OfZbs*$=xpTuY}cS)%ZsX=|2Pc;R^J4pSo7 zS`5<=sg0JX65EwqCQolB^6-m0OK94$+&myNB`nE7Wu`P|htRwDe zt_6{zlU$HkengG!f#v!=f|xQ;blwr0^BpEdw{&Yv)d(@#K|XAnEqJ>OL70wve3ppB z4MXJFX0D2*vkXY1c)de+N2|!&7mH~Q#~_r^@2C)qNMi2WauzqV}Q zvR+D1+2(rbiXEr-fwSU-&;Jmcqm?64-03iW%9*Z%Kl1l%nCwcC>`plo&H4OAJF|qC zvcMh9!U4zZ^P;|&_P5bK*HJT*&Ks`vNtB2qukI#!Yb!#EZQsx-d%wreoUHWFdX?Jz z!!9M$>S3|Q>oDwsIvBB_aeia#<>4s5y>~o*tm%&aY}JoUr|T={um7vq*0!v+aCq{< z^Hj4m z-xXiGa(l35%g9BhAox^%d*$Aey?f@Z{+&7SOa9H075_sXK%$2^W$*ay`!0Q5XEr8U z-jZ-TikG&Tkp78loj!8>i|?KkG;5=c!KWmb=oAUs`Cp^DL0nx~JYz$9$)|;M^ooJF zdEBdrnKuK7M6t{PFzDh6lNy-oJfuz$5AMlEvyE|FaJ=UG`ns zZS*&!m?M3Z56ZF;4bi$iv_*7hpwsSECSRW~uD#)!Hra6Oif{cwe&7NVvrOlOC%YM1 z-XCwa{Jp5#xsttgMTrnQyNe_Ia&-Euwf*8J;j*6OW5(=JUrWtrq#ORFA)YUT{=+^n zI4`^$W3cr=dE;snD)^?OC0B_O>NnQQG#htSo&(n8w2f+rW4~P0;Yp*zzJcZg zPxBT&sv;_?Mr;M&akFMCmr`hQ#Zsc*tjgswkmqjo5o2ZNml`f_mS43byMfa5vT08{ z>fK`0o{6$=`yW<%IQ*VF7x;&6KLqaSK6k0=snd=O|Mh`!ZN{`QD2%EcGJJoX`_dS!xu{V z`xW9l^Mqe6q_$)3i&e@{iG8&i+l?KtHRY)rsg`5J`=lO36LIkwJVBZZJhH4#=l--> zF&y-R=C`WxEu&MM;v_sO=f-cQg$B!iwcDY?X|am^Wg`lg*}Jt#UB8)zWbml#aw+>o zPG`urjLRrrP2(Z&tezv->h@UezdX6J=B=B}sBHXb-V%rNKq8x{`~?EOxeZ$wO;QhN^Z-ZW_; z!tV)nQ@E0?+898^sL$3sANBI;Gob}eN3*>+_n;U>nQR95v_@J2v5ak`{h6X@fmlYR zx$_T$h_S)}@ezzg!S;))i2ZTrfm}=uW5sF`nRTjPhS4_cy^=BLyg>NO>E`<^rz~?& z@V8UvSu;kD4SXL$EvRW(>=?K=g3taT;vYXyi4YByxKoG6{hb42s7L^MIdw)OusDXG zWe3_qO=puz3#@~LJ=%4pDx(liCcTj86i0^J+AEN5*uu#KI+K3s_^@9y!`ICGcB72} zuCOnaGUN$sbHFwDTjF>-o;U|4w!{ZM8_Z;Oc@4pvsAx3O#0UaxKW1w_dp;@5eIK5e zaSs=fE49%%9G;&0USrAgN$~~+@FqR ztqzppfX2Fo0g-Wn)rG99u6-eb4KG}DpI-o*7owu_ia)H zcP4MblLjV$j>9E1d$&dllvfNZ`Ap^+9?JV;_PBQm+ebx2tU8-cK@qiE_}det2<*>m zgvw#csMHh%!zW{xypz3P5zCMPj=C7q@eWvdCy+QI8oA@tB~iXLM9DOTMwuNejU66ktAGt zg~Z5K5UQsqWJF;32NV=lG~ad>w)g25S;;-H?=(T_-daxt*UaL@@-%4>5r}r$Q_=h}Ii+M@(^H->>CEoSY9xl*r}6?To-oyg6}i z7<*RczS+4q4}?sAZA0fD*B|jN4B!T=GJw&S(EJjE-00es-F8rieCe-}z*uLdewW8M;e$(EGz8&(sS~lzw-L%Snr#R_4DZq zLr)f~KSUFp0M>*2QyvvS%6L8YcmyRrI|de?y8Cx9pRPq2
    $PaMt*B>8DMbJ2m8=BnEAAB-!sj=Zyyw#F~ zBfDE;*WM`jkUVx|YRjmT+lUV{=Pdp&a)$vWfthiA6cEa2cB{O$;;)VGjizpI`_Wdh zcxk_qOqf$lbx)7DBME&`WGwczfVswVLu(~>cI;zj_xDdr{)fbd&F=L5L|*nba~^tcW^~enfH2H!-7n2gxEmr?eXZ&HoO6BknDxbaOe=k89T?#Pum#rWz9|1l z#;w#ZNgL!Qb&l*G_qKUM*dbVtR*k9Naosd8YL6kn7Zw_=@vTS19`&wvT;UnEzp6xg z?>}K36yr0-k7p*`EbD*VEwP?6f2X=P<$@_`;Y~6IGfde~Obz>X^u}@2mq@L*zg<~W zsh``qsprCh6DR5tz5=^|koxlM`?}vS-CH*N^HIF=&0OcFvGA%IHQf!xH%zyzo?rW* z%O#}614&W;d7Y}%yhoXLoZNXOpVdMg39?Jz>|*>!9L_D7T52M{;Vt>1voH)6*)fPw z;icZG;r^c{xtq<=A09?HKAWTn!F3y%Kx#&0v7;e*9Rd#`btbjfrYJ%XY&Ua_EDGY0Or00m4=^u{>dvcR0>D%JaZ{Y>6V|6-7pO zS4%y^Yz8N2AfhK}t+foJOo`Eht~3-bEeq&5VW5z=^+Jd|r@1x(gP>`%x)u!MeFDS@ zd`oY@NCskeic(bE5!!pH&S`?0$?{bLb1>Jh=32TBhSUgltEI{j4-WMm9|kEeH(F}R{~1Q#W`NAqEz>e`R2$>B*bYI!^lg6-vo z;*v_UG7{=sX^udeXNfyCScw^yZZh5CSgfqAz*jy;+a(AC9NRKyg+7k$cfPQ&dIOnC zq-Lr&lj9lr6ZDFe=!<5cwT~6S(OPYz)sZd;3Mpcu9?r?9U8mGz1l%ej6OazbbHA|gJUAt zJ#16~y(hTP2urqWA`F@1N!hBEI6!cpn(*tpT_dX27YlW&Ot>@~U$Zl?+aN6I%^wF- z0u}NB+hHIC?uJHOo%)o>5_hsq280>>{AnCYfPT`&56NSoY&3zli};+Bkw$1q<%_Y% zsl$Ufh-0fN=o2t8OtSkgQ=OwlvZn4`YLYpIOm(aLtKsjR0b5fP0!Z(pESks~bPRDuZOLN%JrtQ4v-pif? zTF;-iKP{O$3{&ST^CVet(T$jrZ!b#*1<3f{HV?zEWIOGtd_GoBi(2t*B>7*sRWHt4 z{bM@I%}bXN!{!W-@89359LmjLhvZs5EyGN6FPcn?T>Ew%nfbMR*=&4g^A|m6jV8wB z`7V=PuJxPP4uQw|WYnwyEAeCP`5pSCJ9{t>UX;03A~9taxrGDwK99wpGjEBl7+-v* zIe%g2ajnSlLTc&zis|!@pYrUUL(il3d~p|B`SQ*4J=K>}KJExu^K0OB8_cUn%DJun zwCGTG>t-Wds#n0Y+8;bwoiS@^)Mzu!`7YlNg;i<4udxrKFEn-(YnjPR$FhUU#h-5%o5%|5A&*g&1hZhjTrKfxLd8rD& z6I3@x!psxXXiYwC$qhAHD92%xjo=x5(hD>4{qiOd-XdrcGlFdw26GftT54$}Ow8cVb+kldfZa z^^VEz^5ZNLPfm%-ac3fb@NJ(dg+JQfaQ5lw2{|5|kExT5u>7TALo^K+aS;NFHMv}B zkud5_S?Z248XA=%ns2ue4VnZNP_SGVIu(qPJWwt5KbZ{%#!6~i{ z*<}`2in;PM=x$D#uLYLC!&uSlu2eoYSi_d@)*PfRMQb=Q!vExf@ev=uX|dUJ&+3K zGXr<5JVX0uHhdUg)40kY)aVX{2r`~&$e^jw6QVPjBkg=(&N5qZz!F4Q_UVnAaS=oW zr~po)IH>GU*!7Ll|-`$6kIYz6md0j1A`jDrZbAnq{Ee z)Uv_eYXDy&{U`lP(UsYeVujc%JcE{i8K9_{`1rKp06$bugo}9J_K~OIcjiyHCW?I5 zuvqqAU^`u@Hzgv5XE&GwH$~ZSPw6Cv+8nf_GnZI!?&hA)D*STK z+Wkcw^{Igh!wG)NzPwY59)bjyj<2x_FV9=F90Bkaj}x!mGd<9h$-?4l;HQll_U_E= zD1zWBp?tb@vP>h?B+z?CMlKhl02`l5ZL;|pQ@utI_)J+kkkJ!cik=f-eFBy=)9m2i zRGpeLuy3YmSK6$sH1Z4z(ss^Zgjybxe+M9(#5zHU#7Rtzt9TRgG^Sn{z~k67Zmf7N zz!V7RV&}QGZUIn%%Y`w_-U3x4CQ*ZeV+-uvV0?mV#10GmC787Z8Z7wefU)zFaP0vh z00*At)*6QMkzjc^UlYMkgNfZ;B{>$U!g%5PfazoT$sI#n;s|27=Of+%^rwIMQpn8&7O+IvP4kQI0pI*_s;FiHls8A_gKIH~X;iG>*b zIeMf1lnB_zmeAm?jYMB#E|g{YDPQK8l>%4Mej-twx5+JLFdm`vka+v z$XE%qWkb3=cN`i~oIy~O6CX=N%8KU$Y>Sx+DiranT~8a8tHdk3;6}uY0A+xo%*j;s z22yR4^Ww#D4yYJcg$;ukeUXR&RYne^Bps8WkdC~#Ng-^YyhN$)Hrf(3zNQ(nz~WHd zZO<@;@+qOpH6UZEngqcC*vmt^;|h)OfMb#x=N$rRqX3vGJh+V95gE$UK}3vkM=Ypt zO8*2HI=0OZNe!V|Oa*I_5euo($}3`>>@BF5^EGixG!c61Ckm0LcCt6CPR{mLmf9{c zssNR%sTe)(j)gT+sp%I@IOBE(*m4wJNi6%Pwb`7rK766)Is@5ABR%`zGxOSC z&YWujex?Ifz+Pb8FUPkVCNYU&)rPwp)R=Q^uN9s^q@fW+dINdJ+(13in8Z*XFLL-< z?swzDb8)2wOLO1L^cZN4_e_8pq?Tj5@~aUucv3CtltyH;JOct);Gl#H62Oc|06^On zZVET?>Sb-C?)t`g$l<{*zBWM1kmS4w0ZK9oVjVq+vGPi$J>(_4oc8Nf9BQ#=I2^QFWf5i!(LoQc)n1G&?iNeMtHUL)|%__!abNq zi==W>frD@#-*HMPXTW&sHpdMjDJW7^1khLz!e|-jg_yLYX0#2%8Hzv{hJ&y$5XAw1 z-9wG-F-)DB*2pLp8}$Er0R)P0vJ@Q-@9q=D0)(qTb#Ly>SNLG6*W+C}&UR)mRbI=Y z`N2IS16T&$ncm&W1G6FG(vggd6ZZp$i2fQp)`;S{$N?8k9)f#nQX&?jbB96nN`-)c z<=%Y%rVJSGxm&}t5NalbC&92y0FSY5J&{cjE->{NQ>D`q%i0Y*(CEBx6NCcE5;%`O zKQknZNyJm2g96HiJ38G*D8i*XNQ4+LoB^F&!zC|*PgsH%DLjck9cx3Q6jgmOAmjiW z2l;nD(MSevGXYEBI=4t@1nul#Av`a$a1t+t^dLZOs&_C3ahF9`g{nfjfC8e~NzrUu z$02y03T14*J*bdteX)E;r4Sy^T5B?MgsK#y;Vz*3SL6LZN;jv_hVC*zLVgem!{eJsr(2;CE}{ykGHVk-xw_4z2K=WIGgj4 zxC#<4rJKnW_Opz^H!?u6c_a!Uvky+IPCigE5sSp${4oIYxhRpiQHt2OnRr-c>rYc- z5$yeXjWWpqP{TiyA}ZtZY{(~}AjVb8J(#25e%=8%Ni|IvD|=Q#v!CmgoVSFn6!Cp} z0WKI!c;9=)TY%V(dIIR*-R!En9x?Bs%%+LyD$$=58@B5<&e1<+pt{m24HA{Mb{r_B zeF}>SknoDwc2}BBNu=wMO%_auMn#bo9=24kL?M>J_Pj3^qX$wwk4L(JP&pv+S}shm ze=61z#LW_G_7IC#>%>UH8*)55vk|xhe`mzuN=_r2>5WG2>j4haxPFuV6ntUwj5eiM zir|HXT1>UvYGkvK!VYgvuFzufz&A;Uh8_X3NQDri6-ZIPz3Ji@<_fP9J_D!GVYoizzILR1FoLq{BzOQKhXjD_9<2%M?rC zl_fX;!NN1n$4gBCA?oH0NG;9v@J#&GqNaEyW73L<5ANMuzJK9u>2ODHtbHFEU3c zSW+GFP%gQG%RsTEhH}hnKK4LlD8BqA>id)Fif9hi>f8C+>w8}S!PM;esGswsctm~| z|2eQXq=5aX>vM{#YiHSkb93fNpJEes{HCmkXh=gr(OQ{RX$}GeeWEWp@@A9P!w_w`fIx#+MWI3xiANzsQer z_bo`bzdBnEbi_wogG-Mbu*C6{W6h(7{zz4B|FV0d+Pjx0jP3ws=z^EEFe=wq*kE@E96yu5~84Hf$LD{E$5zRg{#zJg`)fQ1CXzF^dIm zUTbXa3j5BY2M-BbDtCDr6tyla93QV}Z{T)irh|9_QI zz?HRb86=Eb^to;olr6l~p4oMJ=Hlb#QWw{^*(s-2V;;E%(dGB!W^%%^ikm)r-hsmP z>F>YD*NisDmh649=QUw$})%q8xN6Q>-44kS-!Q} zlxL(*Cu8O;^#p3mhH%S!1*&_q0`KI03!!vVSI;xi-x5TI%%nK~*YM0lh)7Vrh{ z_l~w1QbdJJ4iiBQ%Ya`l~_>5~ed_f}#PTMohS5I&;f{pmWok7RvC$6l@iel>`Mv`Jz`VC<=;86+@2^VZjehryzjnz<-e17zt=mOsOeOV6T8r86JAJ5YEn@ zRjt~^?6?8m>MKTIszflvlky0)eDm>A#8;oBCzcv3k=g{&)kf1{$TCHQAS{4U z!LqR0&3byya*R8&xlf?2maC$KKd;Z?GFUaPr*Wr9B`z(tCn%@q3G8goND8YC^d$iYCyX6;M%>cfDEupfY_<0NkDa=l&lA&`OewZv zPQLrp85RpV=o-lfKJ3v(nlt31E@i|Q_}eSg4P!ZeE1%h(Jvh@rq#s=6-v1&Y=doi# z$IU&W+?_+$>XZW?I_G(><8}hST zGH-RbbL34@kE=%i(DQ5cPFr48UYW@s4z#!$`399gansx)pTiYw+)(u9!9T}hs;z48 z#=Q&H$>DuE=NiQQ@S=9z!5P_VC)qy@gG>FtZz@pgKDCy_6s?cE6!(W@(RqQT+M?Lh zi#2;=65i+o-V8~{inmvg?QX6_b{~n#+gT zEAQ?GRAO!Q~rn3 zbIrM_v01l?`^f5jvc>tcb5Ca5qMc&LUH*1_w{Kf}G@N@0Hy9=TG{xc1nkFIepwKa^rzlJJ;Pxp4HN?+N>?f?av9 z%}JkG!CH5m0}nS3W`4%ra4+fir9ColKd`v({#*l07OfsU^zFE5wd<9c>jzPRRz=(g zhx@)l{7YMoswv`^k4!hl+(^NMnX&$dF#kDr*cw}H_|)-9;;{zR`{xGR8foi1 z4DCv;-lR|?8;#sWdPr2yet1xG z;5a#Jf*7n-;!;&}^O$dp=<}m1<5npJWlLYaQpA@`XPbQHTVvgeS)AapjxDM~W7}S7 zz~w-WJNl{KZMnte_}*JtvDN6R}%({EU* z9A}wT*}IVkmo)%0o)@|5tfV33k3*?@t2kcj<*J|W#@;`-U}%u-bLy~TNs~a|f+@9e zEOx_1!G$ep#r?;JfRa5%xfJ62Hl@(oF+&~>EjLt$9??#LF|4n{*@A!y!qZvRQodeJV5Q)c#P)p@=+y=4@>}O>g{t&2(KJwK}ohQ5nZZuz& z+ryoi1pFwa@fq|!>mib^ewZ>P%s$yhF`a@CO1xf8AK#~q`Z3LYt}Tm80ebk-k5CY% zZ$~k|5bXH@38f6Jj^v$ZQX$DjvfhH(!i2ya{I$y)>7Em%G6K#K?lzcmtje8b{J*sU z((f9rnaHpw@$%2XR|L=>%*nKCjTDf9rm?S>U@y@A z Date: Fri, 3 Apr 2020 18:38:55 +0200 Subject: [PATCH 10/22] bugfix for setup.py added fractal marker example image --- aruco_wrap.cxx | 28 ++++++++++++++++++++++++++-- build_wheel.sh | 9 +++++---- example/example.py | 3 +++ okapi-typemaps.i | 30 +++++++++++++++++++++++++++++- setup.py | 3 ++- 5 files changed, 65 insertions(+), 8 deletions(-) diff --git a/aruco_wrap.cxx b/aruco_wrap.cxx index 5bfe523..0443b93 100644 --- a/aruco_wrap.cxx +++ b/aruco_wrap.cxx @@ -6148,6 +6148,18 @@ SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,st return array; } + PyObject* point3f_to_array(cv::Point3f* point) + { + npy_intp dims = 3; + npy_intp strides[1] = { 1 }; + int flags = NPY_WRITEABLE; + float *data = new float[3]; + data[0] = point->x; + data[1] = point->y; + data[2] = point->z; + PyObject* array = PyArray_SimpleNewFromData(1, &dims, NPY_FLOAT, data); + return array; + } SWIGINTERN swig_type_info* @@ -10187,7 +10199,13 @@ SWIGINTERN PyObject *_wrap_CameraParameters_getCameraLocation(PyObject *SWIGUNUS SWIG_fail; } result = aruco::CameraParameters::getCameraLocation((cv::Mat const &)*arg1,(cv::Mat const &)*arg2); - resultobj = SWIG_NewPointerObj((new cv::Point3f(static_cast< const cv::Point3f& >(result))), SWIGTYPE_p_cv__Point3f, SWIG_POINTER_OWN | 0 ); + { + PyObject* array = point3f_to_array(&result); + if (array == NULL) + SWIG_fail; + + resultobj = array; + } { } @@ -23591,7 +23609,13 @@ SWIGINTERN PyObject *_wrap_Marker3DInfo_at(PyObject *SWIGUNUSEDPARM(self), PyObj } arg2 = static_cast< size_t >(val2); result = ((aruco::Marker3DInfo const *)arg1)->at(arg2); - resultobj = SWIG_NewPointerObj((new cv::Point3f(static_cast< const cv::Point3f& >(result))), SWIGTYPE_p_cv__Point3f, SWIG_POINTER_OWN | 0 ); + { + PyObject* array = point3f_to_array(&result); + if (array == NULL) + SWIG_fail; + + resultobj = array; + } return resultobj; fail: return NULL; diff --git a/build_wheel.sh b/build_wheel.sh index 1dae0cc..b2eaebe 100755 --- a/build_wheel.sh +++ b/build_wheel.sh @@ -5,19 +5,20 @@ rm -rf build # build python2 wheel -python setup.py sdist bdist_wheel +#python setup.py sdist bdist_wheel # build python3 wheel python3 setup.py sdist bdist_wheel # create python2 env and run example -rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.1.2.0-cp27-cp27mu-linux_x86_64.whl && 27-sdist/bin/python example/example.py +# rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.1.2.0-cp27-cp27mu-linux_x86_64.whl && cp /home/kolbe/.local/lib/python2.7/site-packages/cv2/cv2.so 27-sdist/lib/python2.7/site-packages/ && 27-sdist/bin/python example/example.py # create python3 env and run example -rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.1.2.0-cp36-cp36m-linux_x86_64.whl && 36-sdist/bin/python example/example.py +rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.1.2.0-cp36-cp36m-linux_x86_64.whl && cp /usr/local/lib/python3.6/dist-packages/cv2/python-3.6/cv2.cpython-36m-x86_64-linux-gnu.so 36-sdist/lib/python3.6/site-packages/ && 36-sdist/bin/python example/example.py +exit 0 # test .tar.gz without wheel # create python2 env and run example -rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.1.2.0.tar.gz && 27-sdist/bin/python example/example.py +#rm -rf 27-sdist && virtualenv 27-sdist && 27-sdist/bin/pip install dist/aruco-3.1.2.0.tar.gz && 27-sdist/bin/python example/example.py # create python3 env and run example rm -rf 36-sdist && virtualenv -p python3 36-sdist && 36-sdist/bin/pip install dist/aruco-3.1.2.0.tar.gz && 36-sdist/bin/python example/example.py \ No newline at end of file diff --git a/example/example.py b/example/example.py index 6689498..ff7148e 100644 --- a/example/example.py +++ b/example/example.py @@ -1,6 +1,8 @@ import os import sys import cv2 +print(cv2.__file__) +print(cv2.__version__) import numpy as np import aruco import pkg_resources # part of setuptools @@ -38,6 +40,7 @@ for i, point in enumerate(marker): print("\t{:d} {}".format(i, str(point))) marker.draw(frame, np.array([255, 255, 255]), 2) + print("3D points: {:}".format(marker.get3DPoints())) # calculate marker extrinsics for marker size of 3.5cm marker.calculateExtrinsics(0.035, camparam) diff --git a/okapi-typemaps.i b/okapi-typemaps.i index 08ca096..02c8815 100644 --- a/okapi-typemaps.i +++ b/okapi-typemaps.i @@ -224,6 +224,18 @@ import_array(); return array; } + PyObject* point3f_to_array(cv::Point3f* point) + { + npy_intp dims = 3; + npy_intp strides[1] = { 1 }; + int flags = NPY_WRITEABLE; + float *data = new float[3]; + data[0] = point->x; + data[1] = point->y; + data[2] = point->z; + PyObject* array = PyArray_SimpleNewFromData(1, &dims, NPY_FLOAT, data); + return array; + } } /////////////////////////////////////// @@ -596,4 +608,20 @@ cv::Point2f SWIG_fail; $result = array; -} \ No newline at end of file +} + +/////////////////////////////////////// +/// return cv::Point3f * +/////////////////////////////////////// + +%typemap(out, + fragment="OKAPI_Fragments") +cv::Point3f +{ + PyObject* array = point3f_to_array(&$1); + if (array == NULL) + SWIG_fail; + + $result = array; +} + diff --git a/setup.py b/setup.py index a2c594e..3536eec 100644 --- a/setup.py +++ b/setup.py @@ -43,7 +43,8 @@ license="Copyright 2011 Rafael Muñoz Salinas. All rights reserved.", url='https://github.com/fehlfarbe/python-aruco', keywords='aruco wrapper', - install_requires=['numpy', 'opencv-contrib-python'], + # install_requires=['numpy', 'opencv-contrib-python'], + install_requires=['numpy'], ext_modules=[aruco_module], py_modules=["aruco"], ) From 17085c1828c5ceeaf805cb63e46fd51afd3e776d Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Mon, 13 Apr 2020 02:38:31 +0200 Subject: [PATCH 11/22] bugfix for setup.py added fractal marker example image --- aruco.i | 1 + aruco_wrap.cxx | 32196 ----------------------------------------- example/example.py | 12 +- okapi-typemaps.i | 39 +- setup.py | 5 +- src/aruco/marker.cpp | 4 + src/aruco/marker.h | 6 +- swigbuild.sh | 2 - 8 files changed, 58 insertions(+), 32207 deletions(-) delete mode 100644 aruco_wrap.cxx diff --git a/aruco.i b/aruco.i index e33829a..c1ed935 100644 --- a/aruco.i +++ b/aruco.i @@ -94,6 +94,7 @@ ArUco stuff // Marker is std::vector< cv::Point2f >, template definition // needed for std::vector -> Python List conversion %template(Point2fVec) std::vector< cv::Point2f >; +%template(Point3fVec) std::vector< cv::Point3f >; %template(MarkerVec) std::vector< aruco::Marker, std::allocator< aruco::Marker > >; %template(VectorMarker3DInfo) std::vector< aruco::Marker3DInfo >; diff --git a/aruco_wrap.cxx b/aruco_wrap.cxx deleted file mode 100644 index 0443b93..0000000 --- a/aruco_wrap.cxx +++ /dev/null @@ -1,32196 +0,0 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.12 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - - -#ifndef SWIGPYTHON -#define SWIGPYTHON -#endif - -#define SWIG_DIRECTORS -#define SWIG_PYTHON_DIRECTOR_NO_VTABLE - - -#ifdef __cplusplus -/* SwigValueWrapper is described in swig.swg */ -template class SwigValueWrapper { - struct SwigMovePointer { - T *ptr; - SwigMovePointer(T *p) : ptr(p) { } - ~SwigMovePointer() { delete ptr; } - SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } - } pointer; - SwigValueWrapper& operator=(const SwigValueWrapper& rhs); - SwigValueWrapper(const SwigValueWrapper& rhs); -public: - SwigValueWrapper() : pointer(0) { } - SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } - operator T&() const { return *pointer.ptr; } - T *operator&() { return pointer.ptr; } -}; - -template T SwigValueInit() { - return T(); -} -#endif - -/* ----------------------------------------------------------------------------- - * This section contains generic SWIG labels for method/variable - * declarations/attributes, and other compiler dependent labels. - * ----------------------------------------------------------------------------- */ - -/* template workaround for compilers that cannot correctly implement the C++ standard */ -#ifndef SWIGTEMPLATEDISAMBIGUATOR -# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) -# define SWIGTEMPLATEDISAMBIGUATOR template -# elif defined(__HP_aCC) -/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ -/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ -# define SWIGTEMPLATEDISAMBIGUATOR template -# else -# define SWIGTEMPLATEDISAMBIGUATOR -# endif -#endif - -/* inline attribute */ -#ifndef SWIGINLINE -# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -# else -# define SWIGINLINE -# endif -#endif - -/* attribute recognised by some compilers to avoid 'unused' warnings */ -#ifndef SWIGUNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -# elif defined(__ICC) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -#endif - -#ifndef SWIG_MSC_UNSUPPRESS_4505 -# if defined(_MSC_VER) -# pragma warning(disable : 4505) /* unreferenced local function has been removed */ -# endif -#endif - -#ifndef SWIGUNUSEDPARM -# ifdef __cplusplus -# define SWIGUNUSEDPARM(p) -# else -# define SWIGUNUSEDPARM(p) p SWIGUNUSED -# endif -#endif - -/* internal SWIG method */ -#ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED -#endif - -/* internal inline SWIG method */ -#ifndef SWIGINTERNINLINE -# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE -#endif - -/* exporting methods */ -#if defined(__GNUC__) -# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -# ifndef GCC_HASCLASSVISIBILITY -# define GCC_HASCLASSVISIBILITY -# endif -# endif -#endif - -#ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) -# define SWIGEXPORT __attribute__ ((visibility("default"))) -# else -# define SWIGEXPORT -# endif -# endif -#endif - -/* calling conventions for Windows */ -#ifndef SWIGSTDCALL -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# define SWIGSTDCALL __stdcall -# else -# define SWIGSTDCALL -# endif -#endif - -/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ -#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) -# define _CRT_SECURE_NO_DEPRECATE -#endif - -/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ -#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) -# define _SCL_SECURE_NO_DEPRECATE -#endif - -/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ -#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) -# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 -#endif - -/* Intel's compiler complains if a variable which was never initialised is - * cast to void, which is a common idiom which we use to indicate that we - * are aware a variable isn't used. So we just silence that warning. - * See: https://github.com/swig/swig/issues/192 for more discussion. - */ -#ifdef __INTEL_COMPILER -# pragma warning disable 592 -#endif - - -#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) -/* Use debug wrappers with the Python release dll */ -# undef _DEBUG -# include -# define _DEBUG -#else -# include -#endif - -/* ----------------------------------------------------------------------------- - * swigrun.swg - * - * This file contains generic C API SWIG runtime support for pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -/* This should only be incremented when either the layout of swig_type_info changes, - or for whatever reason, the runtime changes incompatibly */ -#define SWIG_RUNTIME_VERSION "4" - -/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ -#ifdef SWIG_TYPE_TABLE -# define SWIG_QUOTE_STRING(x) #x -# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) -# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) -#else -# define SWIG_TYPE_TABLE_NAME -#endif - -/* - You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for - creating a static or dynamic library from the SWIG runtime code. - In 99.9% of the cases, SWIG just needs to declare them as 'static'. - - But only do this if strictly necessary, ie, if you have problems - with your compiler or suchlike. -*/ - -#ifndef SWIGRUNTIME -# define SWIGRUNTIME SWIGINTERN -#endif - -#ifndef SWIGRUNTIMEINLINE -# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE -#endif - -/* Generic buffer size */ -#ifndef SWIG_BUFFER_SIZE -# define SWIG_BUFFER_SIZE 1024 -#endif - -/* Flags for pointer conversions */ -#define SWIG_POINTER_DISOWN 0x1 -#define SWIG_CAST_NEW_MEMORY 0x2 - -/* Flags for new pointer objects */ -#define SWIG_POINTER_OWN 0x1 - - -/* - Flags/methods for returning states. - - The SWIG conversion methods, as ConvertPtr, return an integer - that tells if the conversion was successful or not. And if not, - an error code can be returned (see swigerrors.swg for the codes). - - Use the following macros/flags to set or process the returning - states. - - In old versions of SWIG, code such as the following was usually written: - - if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { - // success code - } else { - //fail code - } - - Now you can be more explicit: - - int res = SWIG_ConvertPtr(obj,vptr,ty.flags); - if (SWIG_IsOK(res)) { - // success code - } else { - // fail code - } - - which is the same really, but now you can also do - - Type *ptr; - int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); - if (SWIG_IsOK(res)) { - // success code - if (SWIG_IsNewObj(res) { - ... - delete *ptr; - } else { - ... - } - } else { - // fail code - } - - I.e., now SWIG_ConvertPtr can return new objects and you can - identify the case and take care of the deallocation. Of course that - also requires SWIG_ConvertPtr to return new result values, such as - - int SWIG_ConvertPtr(obj, ptr,...) { - if () { - if () { - *ptr = ; - return SWIG_NEWOBJ; - } else { - *ptr = ; - return SWIG_OLDOBJ; - } - } else { - return SWIG_BADOBJ; - } - } - - Of course, returning the plain '0(success)/-1(fail)' still works, but you can be - more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the - SWIG errors code. - - Finally, if the SWIG_CASTRANK_MODE is enabled, the result code - allows to return the 'cast rank', for example, if you have this - - int food(double) - int fooi(int); - - and you call - - food(1) // cast rank '1' (1 -> 1.0) - fooi(1) // cast rank '0' - - just use the SWIG_AddCast()/SWIG_CheckState() -*/ - -#define SWIG_OK (0) -#define SWIG_ERROR (-1) -#define SWIG_IsOK(r) (r >= 0) -#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) - -/* The CastRankLimit says how many bits are used for the cast rank */ -#define SWIG_CASTRANKLIMIT (1 << 8) -/* The NewMask denotes the object was created (using new/malloc) */ -#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) -/* The TmpMask is for in/out typemaps that use temporal objects */ -#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) -/* Simple returning values */ -#define SWIG_BADOBJ (SWIG_ERROR) -#define SWIG_OLDOBJ (SWIG_OK) -#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) -#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) -/* Check, add and del mask methods */ -#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) -#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) -#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) -#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) -#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) -#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) - -/* Cast-Rank Mode */ -#if defined(SWIG_CASTRANK_MODE) -# ifndef SWIG_TypeRank -# define SWIG_TypeRank unsigned long -# endif -# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ -# define SWIG_MAXCASTRANK (2) -# endif -# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) -# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) -SWIGINTERNINLINE int SWIG_AddCast(int r) { - return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; -} -SWIGINTERNINLINE int SWIG_CheckState(int r) { - return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; -} -#else /* no cast-rank mode */ -# define SWIG_AddCast(r) (r) -# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) -#endif - - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void *(*swig_converter_func)(void *, int *); -typedef struct swig_type_info *(*swig_dycast_func)(void **); - -/* Structure to store information on one type */ -typedef struct swig_type_info { - const char *name; /* mangled name of this type */ - const char *str; /* human readable name of this type */ - swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ - struct swig_cast_info *cast; /* linked list of types that can cast into this type */ - void *clientdata; /* language specific type data */ - int owndata; /* flag if the structure owns the clientdata */ -} swig_type_info; - -/* Structure to store a type and conversion function used for casting */ -typedef struct swig_cast_info { - swig_type_info *type; /* pointer to type that is equivalent to this type */ - swig_converter_func converter; /* function to cast the void pointers */ - struct swig_cast_info *next; /* pointer to next cast in linked list */ - struct swig_cast_info *prev; /* pointer to the previous cast */ -} swig_cast_info; - -/* Structure used to store module information - * Each module generates one structure like this, and the runtime collects - * all of these structures and stores them in a circularly linked list.*/ -typedef struct swig_module_info { - swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ - size_t size; /* Number of types in this module */ - struct swig_module_info *next; /* Pointer to next element in circularly linked list */ - swig_type_info **type_initial; /* Array of initially generated type structures */ - swig_cast_info **cast_initial; /* Array of initially generated casting structures */ - void *clientdata; /* Language specific module data */ -} swig_module_info; - -/* - Compare two type names skipping the space characters, therefore - "char*" == "char *" and "Class" == "Class", etc. - - Return 0 when the two name types are equivalent, as in - strncmp, but skipping ' '. -*/ -SWIGRUNTIME int -SWIG_TypeNameComp(const char *f1, const char *l1, - const char *f2, const char *l2) { - for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { - while ((*f1 == ' ') && (f1 != l1)) ++f1; - while ((*f2 == ' ') && (f2 != l2)) ++f2; - if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; - } - return (int)((l1 - f1) - (l2 - f2)); -} - -/* - Check type equivalence in a name list like ||... - Return 0 if equal, -1 if nb < tb, 1 if nb > tb -*/ -SWIGRUNTIME int -SWIG_TypeCmp(const char *nb, const char *tb) { - int equiv = 1; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (equiv != 0 && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = SWIG_TypeNameComp(nb, ne, tb, te); - if (*ne) ++ne; - } - return equiv; -} - -/* - Check type equivalence in a name list like ||... - Return 0 if not equal, 1 if equal -*/ -SWIGRUNTIME int -SWIG_TypeEquiv(const char *nb, const char *tb) { - return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; -} - -/* - Check the typename -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheck(const char *c, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (strcmp(iter->type->name, c) == 0) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (iter->type == from) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Cast a pointer up an inheritance hierarchy -*/ -SWIGRUNTIMEINLINE void * -SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { - return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); -} - -/* - Dynamic pointer casting. Down an inheritance hierarchy -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { - swig_type_info *lastty = ty; - if (!ty || !ty->dcast) return ty; - while (ty && (ty->dcast)) { - ty = (*ty->dcast)(ptr); - if (ty) lastty = ty; - } - return lastty; -} - -/* - Return the name associated with this type -*/ -SWIGRUNTIMEINLINE const char * -SWIG_TypeName(const swig_type_info *ty) { - return ty->name; -} - -/* - Return the pretty name associated with this type, - that is an unmangled type name in a form presentable to the user. -*/ -SWIGRUNTIME const char * -SWIG_TypePrettyName(const swig_type_info *type) { - /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ - if (!type) return NULL; - if (type->str != NULL) { - const char *last_name = type->str; - const char *s; - for (s = type->str; *s; s++) - if (*s == '|') last_name = s+1; - return last_name; - } - else - return type->name; -} - -/* - Set the clientdata field for a type -*/ -SWIGRUNTIME void -SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_cast_info *cast = ti->cast; - /* if (ti->clientdata == clientdata) return; */ - ti->clientdata = clientdata; - - while (cast) { - if (!cast->converter) { - swig_type_info *tc = cast->type; - if (!tc->clientdata) { - SWIG_TypeClientData(tc, clientdata); - } - } - cast = cast->next; - } -} -SWIGRUNTIME void -SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { - SWIG_TypeClientData(ti, clientdata); - ti->owndata = 1; -} - -/* - Search for a swig_type_info structure only by mangled name - Search is a O(log #types) - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_MangledTypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - swig_module_info *iter = start; - do { - if (iter->size) { - size_t l = 0; - size_t r = iter->size - 1; - do { - /* since l+r >= 0, we can (>> 1) instead (/ 2) */ - size_t i = (l + r) >> 1; - const char *iname = iter->types[i]->name; - if (iname) { - int compare = strcmp(name, iname); - if (compare == 0) { - return iter->types[i]; - } else if (compare < 0) { - if (i) { - r = i - 1; - } else { - break; - } - } else if (compare > 0) { - l = i + 1; - } - } else { - break; /* should never happen */ - } - } while (l <= r); - } - iter = iter->next; - } while (iter != end); - return 0; -} - -/* - Search for a swig_type_info structure for either a mangled name or a human readable name. - It first searches the mangled names of the types, which is a O(log #types) - If a type is not found it then searches the human readable names, which is O(#types). - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - /* STEP 1: Search the name field using binary search */ - swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); - if (ret) { - return ret; - } else { - /* STEP 2: If the type hasn't been found, do a complete search - of the str field (the human readable name) */ - swig_module_info *iter = start; - do { - size_t i = 0; - for (; i < iter->size; ++i) { - if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) - return iter->types[i]; - } - iter = iter->next; - } while (iter != end); - } - - /* neither found a match */ - return 0; -} - -/* - Pack binary data into a string -*/ -SWIGRUNTIME char * -SWIG_PackData(char *c, void *ptr, size_t sz) { - static const char hex[17] = "0123456789abcdef"; - const unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - unsigned char uu = *u; - *(c++) = hex[(uu & 0xf0) >> 4]; - *(c++) = hex[uu & 0xf]; - } - return c; -} - -/* - Unpack binary data from a string -*/ -SWIGRUNTIME const char * -SWIG_UnpackData(const char *c, void *ptr, size_t sz) { - unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - char d = *(c++); - unsigned char uu; - if ((d >= '0') && (d <= '9')) - uu = (unsigned char)((d - '0') << 4); - else if ((d >= 'a') && (d <= 'f')) - uu = (unsigned char)((d - ('a'-10)) << 4); - else - return (char *) 0; - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu |= (unsigned char)(d - '0'); - else if ((d >= 'a') && (d <= 'f')) - uu |= (unsigned char)(d - ('a'-10)); - else - return (char *) 0; - *u = uu; - } - return c; -} - -/* - Pack 'void *' into a string buffer. -*/ -SWIGRUNTIME char * -SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { - char *r = buff; - if ((2*sizeof(void *) + 2) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,&ptr,sizeof(void *)); - if (strlen(name) + 1 > (bsz - (r - buff))) return 0; - strcpy(r,name); - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - *ptr = (void *) 0; - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sizeof(void *)); -} - -SWIGRUNTIME char * -SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { - char *r = buff; - size_t lname = (name ? strlen(name) : 0); - if ((2*sz + 2 + lname) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,ptr,sz); - if (lname) { - strncpy(r,name,lname+1); - } else { - *r = 0; - } - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - memset(ptr,0,sz); - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sz); -} - -#ifdef __cplusplus -} -#endif - -/* Errors in SWIG */ -#define SWIG_UnknownError -1 -#define SWIG_IOError -2 -#define SWIG_RuntimeError -3 -#define SWIG_IndexError -4 -#define SWIG_TypeError -5 -#define SWIG_DivisionByZero -6 -#define SWIG_OverflowError -7 -#define SWIG_SyntaxError -8 -#define SWIG_ValueError -9 -#define SWIG_SystemError -10 -#define SWIG_AttributeError -11 -#define SWIG_MemoryError -12 -#define SWIG_NullReferenceError -13 - - - -/* Compatibility macros for Python 3 */ -#if PY_VERSION_HEX >= 0x03000000 - -#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) -#define PyInt_Check(x) PyLong_Check(x) -#define PyInt_AsLong(x) PyLong_AsLong(x) -#define PyInt_FromLong(x) PyLong_FromLong(x) -#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) -#define PyString_Check(name) PyBytes_Check(name) -#define PyString_FromString(x) PyUnicode_FromString(x) -#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) -#define PyString_AsString(str) PyBytes_AsString(str) -#define PyString_Size(str) PyBytes_Size(str) -#define PyString_InternFromString(key) PyUnicode_InternFromString(key) -#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE -#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) -#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) - -#endif - -#ifndef Py_TYPE -# define Py_TYPE(op) ((op)->ob_type) -#endif - -/* SWIG APIs for compatibility of both Python 2 & 3 */ - -#if PY_VERSION_HEX >= 0x03000000 -# define SWIG_Python_str_FromFormat PyUnicode_FromFormat -#else -# define SWIG_Python_str_FromFormat PyString_FromFormat -#endif - - -/* Warning: This function will allocate a new string in Python 3, - * so please call SWIG_Python_str_DelForPy3(x) to free the space. - */ -SWIGINTERN char* -SWIG_Python_str_AsChar(PyObject *str) -{ -#if PY_VERSION_HEX >= 0x03000000 - char *cstr; - char *newstr; - Py_ssize_t len; - str = PyUnicode_AsUTF8String(str); - PyBytes_AsStringAndSize(str, &cstr, &len); - newstr = (char *) malloc(len+1); - memcpy(newstr, cstr, len+1); - Py_XDECREF(str); - return newstr; -#else - return PyString_AsString(str); -#endif -} - -#if PY_VERSION_HEX >= 0x03000000 -# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) -#else -# define SWIG_Python_str_DelForPy3(x) -#endif - - -SWIGINTERN PyObject* -SWIG_Python_str_FromChar(const char *c) -{ -#if PY_VERSION_HEX >= 0x03000000 - return PyUnicode_FromString(c); -#else - return PyString_FromString(c); -#endif -} - -/* Add PyOS_snprintf for old Pythons */ -#if PY_VERSION_HEX < 0x02020000 -# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) -# define PyOS_snprintf _snprintf -# else -# define PyOS_snprintf snprintf -# endif -#endif - -/* A crude PyString_FromFormat implementation for old Pythons */ -#if PY_VERSION_HEX < 0x02020000 - -#ifndef SWIG_PYBUFFER_SIZE -# define SWIG_PYBUFFER_SIZE 1024 -#endif - -static PyObject * -PyString_FromFormat(const char *fmt, ...) { - va_list ap; - char buf[SWIG_PYBUFFER_SIZE * 2]; - int res; - va_start(ap, fmt); - res = vsnprintf(buf, sizeof(buf), fmt, ap); - va_end(ap); - return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); -} -#endif - -#ifndef PyObject_DEL -# define PyObject_DEL PyObject_Del -#endif - -/* A crude PyExc_StopIteration exception for old Pythons */ -#if PY_VERSION_HEX < 0x02020000 -# ifndef PyExc_StopIteration -# define PyExc_StopIteration PyExc_RuntimeError -# endif -# ifndef PyObject_GenericGetAttr -# define PyObject_GenericGetAttr 0 -# endif -#endif - -/* Py_NotImplemented is defined in 2.1 and up. */ -#if PY_VERSION_HEX < 0x02010000 -# ifndef Py_NotImplemented -# define Py_NotImplemented PyExc_RuntimeError -# endif -#endif - -/* A crude PyString_AsStringAndSize implementation for old Pythons */ -#if PY_VERSION_HEX < 0x02010000 -# ifndef PyString_AsStringAndSize -# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} -# endif -#endif - -/* PySequence_Size for old Pythons */ -#if PY_VERSION_HEX < 0x02000000 -# ifndef PySequence_Size -# define PySequence_Size PySequence_Length -# endif -#endif - -/* PyBool_FromLong for old Pythons */ -#if PY_VERSION_HEX < 0x02030000 -static -PyObject *PyBool_FromLong(long ok) -{ - PyObject *result = ok ? Py_True : Py_False; - Py_INCREF(result); - return result; -} -#endif - -/* Py_ssize_t for old Pythons */ -/* This code is as recommended by: */ -/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ -#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) -typedef int Py_ssize_t; -# define PY_SSIZE_T_MAX INT_MAX -# define PY_SSIZE_T_MIN INT_MIN -typedef inquiry lenfunc; -typedef intargfunc ssizeargfunc; -typedef intintargfunc ssizessizeargfunc; -typedef intobjargproc ssizeobjargproc; -typedef intintobjargproc ssizessizeobjargproc; -typedef getreadbufferproc readbufferproc; -typedef getwritebufferproc writebufferproc; -typedef getsegcountproc segcountproc; -typedef getcharbufferproc charbufferproc; -static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) -{ - long result = 0; - PyObject *i = PyNumber_Int(x); - if (i) { - result = PyInt_AsLong(i); - Py_DECREF(i); - } - return result; -} -#endif - -#if PY_VERSION_HEX < 0x02050000 -#define PyInt_FromSize_t(x) PyInt_FromLong((long)x) -#endif - -#if PY_VERSION_HEX < 0x02040000 -#define Py_VISIT(op) \ - do { \ - if (op) { \ - int vret = visit((op), arg); \ - if (vret) \ - return vret; \ - } \ - } while (0) -#endif - -#if PY_VERSION_HEX < 0x02030000 -typedef struct { - PyTypeObject type; - PyNumberMethods as_number; - PyMappingMethods as_mapping; - PySequenceMethods as_sequence; - PyBufferProcs as_buffer; - PyObject *name, *slots; -} PyHeapTypeObject; -#endif - -#if PY_VERSION_HEX < 0x02030000 -typedef destructor freefunc; -#endif - -#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ - (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ - (PY_MAJOR_VERSION > 3)) -# define SWIGPY_USE_CAPSULE -# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) -#endif - -#if PY_VERSION_HEX < 0x03020000 -#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) -#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) -#define Py_hash_t long -#endif - -/* ----------------------------------------------------------------------------- - * error manipulation - * ----------------------------------------------------------------------------- */ - -SWIGRUNTIME PyObject* -SWIG_Python_ErrorType(int code) { - PyObject* type = 0; - switch(code) { - case SWIG_MemoryError: - type = PyExc_MemoryError; - break; - case SWIG_IOError: - type = PyExc_IOError; - break; - case SWIG_RuntimeError: - type = PyExc_RuntimeError; - break; - case SWIG_IndexError: - type = PyExc_IndexError; - break; - case SWIG_TypeError: - type = PyExc_TypeError; - break; - case SWIG_DivisionByZero: - type = PyExc_ZeroDivisionError; - break; - case SWIG_OverflowError: - type = PyExc_OverflowError; - break; - case SWIG_SyntaxError: - type = PyExc_SyntaxError; - break; - case SWIG_ValueError: - type = PyExc_ValueError; - break; - case SWIG_SystemError: - type = PyExc_SystemError; - break; - case SWIG_AttributeError: - type = PyExc_AttributeError; - break; - default: - type = PyExc_RuntimeError; - } - return type; -} - - -SWIGRUNTIME void -SWIG_Python_AddErrorMsg(const char* mesg) -{ - PyObject *type = 0; - PyObject *value = 0; - PyObject *traceback = 0; - - if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); - if (value) { - char *tmp; - PyObject *old_str = PyObject_Str(value); - PyErr_Clear(); - Py_XINCREF(type); - - PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); - Py_DECREF(value); - } else { - PyErr_SetString(PyExc_RuntimeError, mesg); - } -} - -#if defined(SWIG_PYTHON_NO_THREADS) -# if defined(SWIG_PYTHON_THREADS) -# undef SWIG_PYTHON_THREADS -# endif -#endif -#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ -# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) -# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ -# define SWIG_PYTHON_USE_GIL -# endif -# endif -# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ -# ifndef SWIG_PYTHON_INITIALIZE_THREADS -# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() -# endif -# ifdef __cplusplus /* C++ code */ - class SWIG_Python_Thread_Block { - bool status; - PyGILState_STATE state; - public: - void end() { if (status) { PyGILState_Release(state); status = false;} } - SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} - ~SWIG_Python_Thread_Block() { end(); } - }; - class SWIG_Python_Thread_Allow { - bool status; - PyThreadState *save; - public: - void end() { if (status) { PyEval_RestoreThread(save); status = false; }} - SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} - ~SWIG_Python_Thread_Allow() { end(); } - }; -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block -# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow -# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() -# else /* C code */ -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() -# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() -# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) -# endif -# else /* Old thread way, not implemented, user must provide it */ -# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) -# define SWIG_PYTHON_INITIALIZE_THREADS -# endif -# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK -# endif -# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) -# define SWIG_PYTHON_THREAD_END_BLOCK -# endif -# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW -# endif -# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) -# define SWIG_PYTHON_THREAD_END_ALLOW -# endif -# endif -#else /* No thread support */ -# define SWIG_PYTHON_INITIALIZE_THREADS -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK -# define SWIG_PYTHON_THREAD_END_BLOCK -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW -# define SWIG_PYTHON_THREAD_END_ALLOW -#endif - -/* ----------------------------------------------------------------------------- - * Python API portion that goes into the runtime - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#endif - -/* ----------------------------------------------------------------------------- - * Constant declarations - * ----------------------------------------------------------------------------- */ - -/* Constant Types */ -#define SWIG_PY_POINTER 4 -#define SWIG_PY_BINARY 5 - -/* Constant information structure */ -typedef struct swig_const_info { - int type; - char *name; - long lvalue; - double dvalue; - void *pvalue; - swig_type_info **ptype; -} swig_const_info; - - -/* ----------------------------------------------------------------------------- - * Wrapper of PyInstanceMethod_New() used in Python 3 - * It is exported to the generated module, used for -fastproxy - * ----------------------------------------------------------------------------- */ -#if PY_VERSION_HEX >= 0x03000000 -SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) -{ - return PyInstanceMethod_New(func); -} -#else -SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) -{ - return NULL; -} -#endif - -#ifdef __cplusplus -} -#endif - - -/* ----------------------------------------------------------------------------- - * pyrun.swg - * - * This file contains the runtime support for Python modules - * and includes code for managing global variables and pointer - * type checking. - * - * ----------------------------------------------------------------------------- */ - -/* Common SWIG API */ - -/* for raw pointers */ -#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) -#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) -#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) - -#ifdef SWIGPYTHON_BUILTIN -#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) -#else -#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) -#endif - -#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) - -#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) -#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) -#define swig_owntype int - -/* for raw packed data */ -#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) -#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) - -/* for class or struct pointers */ -#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) -#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) - -/* for C or C++ function pointers */ -#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) -#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) - -/* for C++ member pointers, ie, member methods */ -#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) -#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) - - -/* Runtime API */ - -#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) -#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) -#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) - -#define SWIG_SetErrorObj SWIG_Python_SetErrorObj -#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg -#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) -#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) -#define SWIG_fail goto fail - - -/* Runtime API implementation */ - -/* Error manipulation */ - -SWIGINTERN void -SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - PyErr_SetObject(errtype, obj); - Py_DECREF(obj); - SWIG_PYTHON_THREAD_END_BLOCK; -} - -SWIGINTERN void -SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - PyErr_SetString(errtype, msg); - SWIG_PYTHON_THREAD_END_BLOCK; -} - -#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) - -/* Set a constant value */ - -#if defined(SWIGPYTHON_BUILTIN) - -SWIGINTERN void -SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { - PyObject *s = PyString_InternFromString(key); - PyList_Append(seq, s); - Py_DECREF(s); -} - -SWIGINTERN void -SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { -#if PY_VERSION_HEX < 0x02030000 - PyDict_SetItemString(d, (char *)name, obj); -#else - PyDict_SetItemString(d, name, obj); -#endif - Py_DECREF(obj); - if (public_interface) - SwigPyBuiltin_AddPublicSymbol(public_interface, name); -} - -#else - -SWIGINTERN void -SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { -#if PY_VERSION_HEX < 0x02030000 - PyDict_SetItemString(d, (char *)name, obj); -#else - PyDict_SetItemString(d, name, obj); -#endif - Py_DECREF(obj); -} - -#endif - -/* Append a value to the result obj */ - -SWIGINTERN PyObject* -SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { -#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) - if (!result) { - result = obj; - } else if (result == Py_None) { - Py_DECREF(result); - result = obj; - } else { - if (!PyList_Check(result)) { - PyObject *o2 = result; - result = PyList_New(1); - PyList_SetItem(result, 0, o2); - } - PyList_Append(result,obj); - Py_DECREF(obj); - } - return result; -#else - PyObject* o2; - PyObject* o3; - if (!result) { - result = obj; - } else if (result == Py_None) { - Py_DECREF(result); - result = obj; - } else { - if (!PyTuple_Check(result)) { - o2 = result; - result = PyTuple_New(1); - PyTuple_SET_ITEM(result, 0, o2); - } - o3 = PyTuple_New(1); - PyTuple_SET_ITEM(o3, 0, obj); - o2 = result; - result = PySequence_Concat(o2, o3); - Py_DECREF(o2); - Py_DECREF(o3); - } - return result; -#endif -} - -/* Unpack the argument tuple */ - -SWIGINTERN Py_ssize_t -SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) -{ - if (!args) { - if (!min && !max) { - return 1; - } else { - PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", - name, (min == max ? "" : "at least "), (int)min); - return 0; - } - } - if (!PyTuple_Check(args)) { - if (min <= 1 && max >= 1) { - Py_ssize_t i; - objs[0] = args; - for (i = 1; i < max; ++i) { - objs[i] = 0; - } - return 2; - } - PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); - return 0; - } else { - Py_ssize_t l = PyTuple_GET_SIZE(args); - if (l < min) { - PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", - name, (min == max ? "" : "at least "), (int)min, (int)l); - return 0; - } else if (l > max) { - PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", - name, (min == max ? "" : "at most "), (int)max, (int)l); - return 0; - } else { - Py_ssize_t i; - for (i = 0; i < l; ++i) { - objs[i] = PyTuple_GET_ITEM(args, i); - } - for (; l < max; ++l) { - objs[l] = 0; - } - return i + 1; - } - } -} - -/* A functor is a function object with one single object argument */ -#if PY_VERSION_HEX >= 0x02020000 -#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); -#else -#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); -#endif - -/* - Helper for static pointer initialization for both C and C++ code, for example - static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); -*/ -#ifdef __cplusplus -#define SWIG_STATIC_POINTER(var) var -#else -#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var -#endif - -/* ----------------------------------------------------------------------------- - * Pointer declarations - * ----------------------------------------------------------------------------- */ - -/* Flags for new pointer objects */ -#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) -#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) - -#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) - -#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) -#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) - -#ifdef __cplusplus -extern "C" { -#endif - -/* How to access Py_None */ -#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# ifndef SWIG_PYTHON_NO_BUILD_NONE -# ifndef SWIG_PYTHON_BUILD_NONE -# define SWIG_PYTHON_BUILD_NONE -# endif -# endif -#endif - -#ifdef SWIG_PYTHON_BUILD_NONE -# ifdef Py_None -# undef Py_None -# define Py_None SWIG_Py_None() -# endif -SWIGRUNTIMEINLINE PyObject * -_SWIG_Py_None(void) -{ - PyObject *none = Py_BuildValue((char*)""); - Py_DECREF(none); - return none; -} -SWIGRUNTIME PyObject * -SWIG_Py_None(void) -{ - static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); - return none; -} -#endif - -/* The python void return value */ - -SWIGRUNTIMEINLINE PyObject * -SWIG_Py_Void(void) -{ - PyObject *none = Py_None; - Py_INCREF(none); - return none; -} - -/* SwigPyClientData */ - -typedef struct { - PyObject *klass; - PyObject *newraw; - PyObject *newargs; - PyObject *destroy; - int delargs; - int implicitconv; - PyTypeObject *pytype; -} SwigPyClientData; - -SWIGRUNTIMEINLINE int -SWIG_Python_CheckImplicit(swig_type_info *ty) -{ - SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; - return data ? data->implicitconv : 0; -} - -SWIGRUNTIMEINLINE PyObject * -SWIG_Python_ExceptionType(swig_type_info *desc) { - SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; - PyObject *klass = data ? data->klass : 0; - return (klass ? klass : PyExc_RuntimeError); -} - - -SWIGRUNTIME SwigPyClientData * -SwigPyClientData_New(PyObject* obj) -{ - if (!obj) { - return 0; - } else { - SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); - /* the klass element */ - data->klass = obj; - Py_INCREF(data->klass); - /* the newraw method and newargs arguments used to create a new raw instance */ - if (PyClass_Check(obj)) { - data->newraw = 0; - data->newargs = obj; - Py_INCREF(obj); - } else { -#if (PY_VERSION_HEX < 0x02020000) - data->newraw = 0; -#else - data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); -#endif - if (data->newraw) { - Py_INCREF(data->newraw); - data->newargs = PyTuple_New(1); - PyTuple_SetItem(data->newargs, 0, obj); - } else { - data->newargs = obj; - } - Py_INCREF(data->newargs); - } - /* the destroy method, aka as the C++ delete method */ - data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); - if (PyErr_Occurred()) { - PyErr_Clear(); - data->destroy = 0; - } - if (data->destroy) { - int flags; - Py_INCREF(data->destroy); - flags = PyCFunction_GET_FLAGS(data->destroy); -#ifdef METH_O - data->delargs = !(flags & (METH_O)); -#else - data->delargs = 0; -#endif - } else { - data->delargs = 0; - } - data->implicitconv = 0; - data->pytype = 0; - return data; - } -} - -SWIGRUNTIME void -SwigPyClientData_Del(SwigPyClientData *data) { - Py_XDECREF(data->newraw); - Py_XDECREF(data->newargs); - Py_XDECREF(data->destroy); -} - -/* =============== SwigPyObject =====================*/ - -typedef struct { - PyObject_HEAD - void *ptr; - swig_type_info *ty; - int own; - PyObject *next; -#ifdef SWIGPYTHON_BUILTIN - PyObject *dict; -#endif -} SwigPyObject; - - -#ifdef SWIGPYTHON_BUILTIN - -SWIGRUNTIME PyObject * -SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) -{ - SwigPyObject *sobj = (SwigPyObject *)v; - - if (!sobj->dict) - sobj->dict = PyDict_New(); - - Py_INCREF(sobj->dict); - return sobj->dict; -} - -#endif - -SWIGRUNTIME PyObject * -SwigPyObject_long(SwigPyObject *v) -{ - return PyLong_FromVoidPtr(v->ptr); -} - -SWIGRUNTIME PyObject * -SwigPyObject_format(const char* fmt, SwigPyObject *v) -{ - PyObject *res = NULL; - PyObject *args = PyTuple_New(1); - if (args) { - if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { - PyObject *ofmt = SWIG_Python_str_FromChar(fmt); - if (ofmt) { -#if PY_VERSION_HEX >= 0x03000000 - res = PyUnicode_Format(ofmt,args); -#else - res = PyString_Format(ofmt,args); -#endif - Py_DECREF(ofmt); - } - Py_DECREF(args); - } - } - return res; -} - -SWIGRUNTIME PyObject * -SwigPyObject_oct(SwigPyObject *v) -{ - return SwigPyObject_format("%o",v); -} - -SWIGRUNTIME PyObject * -SwigPyObject_hex(SwigPyObject *v) -{ - return SwigPyObject_format("%x",v); -} - -SWIGRUNTIME PyObject * -#ifdef METH_NOARGS -SwigPyObject_repr(SwigPyObject *v) -#else -SwigPyObject_repr(SwigPyObject *v, PyObject *args) -#endif -{ - const char *name = SWIG_TypePrettyName(v->ty); - PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); - if (v->next) { -# ifdef METH_NOARGS - PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); -# else - PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); -# endif -# if PY_VERSION_HEX >= 0x03000000 - PyObject *joined = PyUnicode_Concat(repr, nrep); - Py_DecRef(repr); - Py_DecRef(nrep); - repr = joined; -# else - PyString_ConcatAndDel(&repr,nrep); -# endif - } - return repr; -} - -SWIGRUNTIME int -SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) -{ - void *i = v->ptr; - void *j = w->ptr; - return (i < j) ? -1 : ((i > j) ? 1 : 0); -} - -/* Added for Python 3.x, would it also be useful for Python 2.x? */ -SWIGRUNTIME PyObject* -SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) -{ - PyObject* res; - if( op != Py_EQ && op != Py_NE ) { - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; - } - res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); - return res; -} - - -SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); - -#ifdef SWIGPYTHON_BUILTIN -static swig_type_info *SwigPyObject_stype = 0; -SWIGRUNTIME PyTypeObject* -SwigPyObject_type(void) { - SwigPyClientData *cd; - assert(SwigPyObject_stype); - cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; - assert(cd); - assert(cd->pytype); - return cd->pytype; -} -#else -SWIGRUNTIME PyTypeObject* -SwigPyObject_type(void) { - static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); - return type; -} -#endif - -SWIGRUNTIMEINLINE int -SwigPyObject_Check(PyObject *op) { -#ifdef SWIGPYTHON_BUILTIN - PyTypeObject *target_tp = SwigPyObject_type(); - if (PyType_IsSubtype(op->ob_type, target_tp)) - return 1; - return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); -#else - return (Py_TYPE(op) == SwigPyObject_type()) - || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); -#endif -} - -SWIGRUNTIME PyObject * -SwigPyObject_New(void *ptr, swig_type_info *ty, int own); - -SWIGRUNTIME void -SwigPyObject_dealloc(PyObject *v) -{ - SwigPyObject *sobj = (SwigPyObject *) v; - PyObject *next = sobj->next; - if (sobj->own == SWIG_POINTER_OWN) { - swig_type_info *ty = sobj->ty; - SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; - PyObject *destroy = data ? data->destroy : 0; - if (destroy) { - /* destroy is always a VARARGS method */ - PyObject *res; - - /* PyObject_CallFunction() has the potential to silently drop - the active active exception. In cases of unnamed temporary - variable or where we just finished iterating over a generator - StopIteration will be active right now, and this needs to - remain true upon return from SwigPyObject_dealloc. So save - and restore. */ - - PyObject *val = NULL, *type = NULL, *tb = NULL; - PyErr_Fetch(&val, &type, &tb); - - if (data->delargs) { - /* we need to create a temporary object to carry the destroy operation */ - PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); - res = SWIG_Python_CallFunctor(destroy, tmp); - Py_DECREF(tmp); - } else { - PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); - PyObject *mself = PyCFunction_GET_SELF(destroy); - res = ((*meth)(mself, v)); - } - if (!res) - PyErr_WriteUnraisable(destroy); - - PyErr_Restore(val, type, tb); - - Py_XDECREF(res); - } -#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) - else { - const char *name = SWIG_TypePrettyName(ty); - printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); - } -#endif - } - Py_XDECREF(next); - PyObject_DEL(v); -} - -SWIGRUNTIME PyObject* -SwigPyObject_append(PyObject* v, PyObject* next) -{ - SwigPyObject *sobj = (SwigPyObject *) v; -#ifndef METH_O - PyObject *tmp = 0; - if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; - next = tmp; -#endif - if (!SwigPyObject_Check(next)) { - PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); - return NULL; - } - sobj->next = next; - Py_INCREF(next); - return SWIG_Py_Void(); -} - -SWIGRUNTIME PyObject* -#ifdef METH_NOARGS -SwigPyObject_next(PyObject* v) -#else -SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) -#endif -{ - SwigPyObject *sobj = (SwigPyObject *) v; - if (sobj->next) { - Py_INCREF(sobj->next); - return sobj->next; - } else { - return SWIG_Py_Void(); - } -} - -SWIGINTERN PyObject* -#ifdef METH_NOARGS -SwigPyObject_disown(PyObject *v) -#else -SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) -#endif -{ - SwigPyObject *sobj = (SwigPyObject *)v; - sobj->own = 0; - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject* -#ifdef METH_NOARGS -SwigPyObject_acquire(PyObject *v) -#else -SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) -#endif -{ - SwigPyObject *sobj = (SwigPyObject *)v; - sobj->own = SWIG_POINTER_OWN; - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject* -SwigPyObject_own(PyObject *v, PyObject *args) -{ - PyObject *val = 0; -#if (PY_VERSION_HEX < 0x02020000) - if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) -#elif (PY_VERSION_HEX < 0x02050000) - if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) -#else - if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) -#endif - { - return NULL; - } - else - { - SwigPyObject *sobj = (SwigPyObject *)v; - PyObject *obj = PyBool_FromLong(sobj->own); - if (val) { -#ifdef METH_NOARGS - if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v); - } else { - SwigPyObject_disown(v); - } -#else - if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v,args); - } else { - SwigPyObject_disown(v,args); - } -#endif - } - return obj; - } -} - -#ifdef METH_O -static PyMethodDef -swigobject_methods[] = { - {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, - {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"}, - {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, - {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, - {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, - {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"}, - {0, 0, 0, 0} -}; -#else -static PyMethodDef -swigobject_methods[] = { - {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, - {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"}, - {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, - {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, - {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, - {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, - {0, 0, 0, 0} -}; -#endif - -#if PY_VERSION_HEX < 0x02020000 -SWIGINTERN PyObject * -SwigPyObject_getattr(SwigPyObject *sobj,char *name) -{ - return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); -} -#endif - -SWIGRUNTIME PyTypeObject* -SwigPyObject_TypeOnce(void) { - static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; - - static PyNumberMethods SwigPyObject_as_number = { - (binaryfunc)0, /*nb_add*/ - (binaryfunc)0, /*nb_subtract*/ - (binaryfunc)0, /*nb_multiply*/ - /* nb_divide removed in Python 3 */ -#if PY_VERSION_HEX < 0x03000000 - (binaryfunc)0, /*nb_divide*/ -#endif - (binaryfunc)0, /*nb_remainder*/ - (binaryfunc)0, /*nb_divmod*/ - (ternaryfunc)0,/*nb_power*/ - (unaryfunc)0, /*nb_negative*/ - (unaryfunc)0, /*nb_positive*/ - (unaryfunc)0, /*nb_absolute*/ - (inquiry)0, /*nb_nonzero*/ - 0, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - 0, /*nb_and*/ - 0, /*nb_xor*/ - 0, /*nb_or*/ -#if PY_VERSION_HEX < 0x03000000 - 0, /*nb_coerce*/ -#endif - (unaryfunc)SwigPyObject_long, /*nb_int*/ -#if PY_VERSION_HEX < 0x03000000 - (unaryfunc)SwigPyObject_long, /*nb_long*/ -#else - 0, /*nb_reserved*/ -#endif - (unaryfunc)0, /*nb_float*/ -#if PY_VERSION_HEX < 0x03000000 - (unaryfunc)SwigPyObject_oct, /*nb_oct*/ - (unaryfunc)SwigPyObject_hex, /*nb_hex*/ -#endif -#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ -#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ -#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ -#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ -#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ - 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ -#endif - }; - - static PyTypeObject swigpyobject_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { -#if PY_VERSION_HEX >= 0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) -#else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ -#endif - (char *)"SwigPyObject", /* tp_name */ - sizeof(SwigPyObject), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor)SwigPyObject_dealloc, /* tp_dealloc */ - 0, /* tp_print */ -#if PY_VERSION_HEX < 0x02020000 - (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ -#else - (getattrfunc)0, /* tp_getattr */ -#endif - (setattrfunc)0, /* tp_setattr */ -#if PY_VERSION_HEX >= 0x03000000 - 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ -#else - (cmpfunc)SwigPyObject_compare, /* tp_compare */ -#endif - (reprfunc)SwigPyObject_repr, /* tp_repr */ - &SwigPyObject_as_number, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - (hashfunc)0, /* tp_hash */ - (ternaryfunc)0, /* tp_call */ - 0, /* tp_str */ - PyObject_GenericGetAttr, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT, /* tp_flags */ - swigobject_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ - 0, /* tp_weaklistoffset */ -#if PY_VERSION_HEX >= 0x02020000 - 0, /* tp_iter */ - 0, /* tp_iternext */ - swigobject_methods, /* tp_methods */ - 0, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - 0, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ - 0, /* tp_free */ - 0, /* tp_is_gc */ - 0, /* tp_bases */ - 0, /* tp_mro */ - 0, /* tp_cache */ - 0, /* tp_subclasses */ - 0, /* tp_weaklist */ -#endif -#if PY_VERSION_HEX >= 0x02030000 - 0, /* tp_del */ -#endif -#if PY_VERSION_HEX >= 0x02060000 - 0, /* tp_version_tag */ -#endif -#if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ -#endif -#ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ -#if PY_VERSION_HEX >= 0x02050000 - 0, /* tp_prev */ -#endif - 0 /* tp_next */ -#endif - }; - swigpyobject_type = tmp; - type_init = 1; -#if PY_VERSION_HEX < 0x02020000 - swigpyobject_type.ob_type = &PyType_Type; -#else - if (PyType_Ready(&swigpyobject_type) < 0) - return NULL; -#endif - } - return &swigpyobject_type; -} - -SWIGRUNTIME PyObject * -SwigPyObject_New(void *ptr, swig_type_info *ty, int own) -{ - SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); - if (sobj) { - sobj->ptr = ptr; - sobj->ty = ty; - sobj->own = own; - sobj->next = 0; - } - return (PyObject *)sobj; -} - -/* ----------------------------------------------------------------------------- - * Implements a simple Swig Packed type, and use it instead of string - * ----------------------------------------------------------------------------- */ - -typedef struct { - PyObject_HEAD - void *pack; - swig_type_info *ty; - size_t size; -} SwigPyPacked; - -SWIGRUNTIME int -SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) -{ - char result[SWIG_BUFFER_SIZE]; - fputs("pack, v->size, 0, sizeof(result))) { - fputs("at ", fp); - fputs(result, fp); - } - fputs(v->ty->name,fp); - fputs(">", fp); - return 0; -} - -SWIGRUNTIME PyObject * -SwigPyPacked_repr(SwigPyPacked *v) -{ - char result[SWIG_BUFFER_SIZE]; - if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { - return SWIG_Python_str_FromFormat("", result, v->ty->name); - } else { - return SWIG_Python_str_FromFormat("", v->ty->name); - } -} - -SWIGRUNTIME PyObject * -SwigPyPacked_str(SwigPyPacked *v) -{ - char result[SWIG_BUFFER_SIZE]; - if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ - return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); - } else { - return SWIG_Python_str_FromChar(v->ty->name); - } -} - -SWIGRUNTIME int -SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) -{ - size_t i = v->size; - size_t j = w->size; - int s = (i < j) ? -1 : ((i > j) ? 1 : 0); - return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); -} - -SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); - -SWIGRUNTIME PyTypeObject* -SwigPyPacked_type(void) { - static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); - return type; -} - -SWIGRUNTIMEINLINE int -SwigPyPacked_Check(PyObject *op) { - return ((op)->ob_type == SwigPyPacked_TypeOnce()) - || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); -} - -SWIGRUNTIME void -SwigPyPacked_dealloc(PyObject *v) -{ - if (SwigPyPacked_Check(v)) { - SwigPyPacked *sobj = (SwigPyPacked *) v; - free(sobj->pack); - } - PyObject_DEL(v); -} - -SWIGRUNTIME PyTypeObject* -SwigPyPacked_TypeOnce(void) { - static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; - static PyTypeObject swigpypacked_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { -#if PY_VERSION_HEX>=0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) -#else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ -#endif - (char *)"SwigPyPacked", /* tp_name */ - sizeof(SwigPyPacked), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ - (printfunc)SwigPyPacked_print, /* tp_print */ - (getattrfunc)0, /* tp_getattr */ - (setattrfunc)0, /* tp_setattr */ -#if PY_VERSION_HEX>=0x03000000 - 0, /* tp_reserved in 3.0.1 */ -#else - (cmpfunc)SwigPyPacked_compare, /* tp_compare */ -#endif - (reprfunc)SwigPyPacked_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - (hashfunc)0, /* tp_hash */ - (ternaryfunc)0, /* tp_call */ - (reprfunc)SwigPyPacked_str, /* tp_str */ - PyObject_GenericGetAttr, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT, /* tp_flags */ - swigpacked_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ -#if PY_VERSION_HEX >= 0x02020000 - 0, /* tp_iter */ - 0, /* tp_iternext */ - 0, /* tp_methods */ - 0, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - 0, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ - 0, /* tp_free */ - 0, /* tp_is_gc */ - 0, /* tp_bases */ - 0, /* tp_mro */ - 0, /* tp_cache */ - 0, /* tp_subclasses */ - 0, /* tp_weaklist */ -#endif -#if PY_VERSION_HEX >= 0x02030000 - 0, /* tp_del */ -#endif -#if PY_VERSION_HEX >= 0x02060000 - 0, /* tp_version_tag */ -#endif -#if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ -#endif -#ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ -#if PY_VERSION_HEX >= 0x02050000 - 0, /* tp_prev */ -#endif - 0 /* tp_next */ -#endif - }; - swigpypacked_type = tmp; - type_init = 1; -#if PY_VERSION_HEX < 0x02020000 - swigpypacked_type.ob_type = &PyType_Type; -#else - if (PyType_Ready(&swigpypacked_type) < 0) - return NULL; -#endif - } - return &swigpypacked_type; -} - -SWIGRUNTIME PyObject * -SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) -{ - SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); - if (sobj) { - void *pack = malloc(size); - if (pack) { - memcpy(pack, ptr, size); - sobj->pack = pack; - sobj->ty = ty; - sobj->size = size; - } else { - PyObject_DEL((PyObject *) sobj); - sobj = 0; - } - } - return (PyObject *) sobj; -} - -SWIGRUNTIME swig_type_info * -SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) -{ - if (SwigPyPacked_Check(obj)) { - SwigPyPacked *sobj = (SwigPyPacked *)obj; - if (sobj->size != size) return 0; - memcpy(ptr, sobj->pack, size); - return sobj->ty; - } else { - return 0; - } -} - -/* ----------------------------------------------------------------------------- - * pointers/data manipulation - * ----------------------------------------------------------------------------- */ - -SWIGRUNTIMEINLINE PyObject * -_SWIG_This(void) -{ - return SWIG_Python_str_FromChar("this"); -} - -static PyObject *swig_this = NULL; - -SWIGRUNTIME PyObject * -SWIG_This(void) -{ - if (swig_this == NULL) - swig_this = _SWIG_This(); - return swig_this; -} - -/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ - -/* TODO: I don't know how to implement the fast getset in Python 3 right now */ -#if PY_VERSION_HEX>=0x03000000 -#define SWIG_PYTHON_SLOW_GETSET_THIS -#endif - -SWIGRUNTIME SwigPyObject * -SWIG_Python_GetSwigThis(PyObject *pyobj) -{ - PyObject *obj; - - if (SwigPyObject_Check(pyobj)) - return (SwigPyObject *) pyobj; - -#ifdef SWIGPYTHON_BUILTIN - (void)obj; -# ifdef PyWeakref_CheckProxy - if (PyWeakref_CheckProxy(pyobj)) { - pyobj = PyWeakref_GET_OBJECT(pyobj); - if (pyobj && SwigPyObject_Check(pyobj)) - return (SwigPyObject*) pyobj; - } -# endif - return NULL; -#else - - obj = 0; - -#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) - if (PyInstance_Check(pyobj)) { - obj = _PyInstance_Lookup(pyobj, SWIG_This()); - } else { - PyObject **dictptr = _PyObject_GetDictPtr(pyobj); - if (dictptr != NULL) { - PyObject *dict = *dictptr; - obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; - } else { -#ifdef PyWeakref_CheckProxy - if (PyWeakref_CheckProxy(pyobj)) { - PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); - return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; - } -#endif - obj = PyObject_GetAttr(pyobj,SWIG_This()); - if (obj) { - Py_DECREF(obj); - } else { - if (PyErr_Occurred()) PyErr_Clear(); - return 0; - } - } - } -#else - obj = PyObject_GetAttr(pyobj,SWIG_This()); - if (obj) { - Py_DECREF(obj); - } else { - if (PyErr_Occurred()) PyErr_Clear(); - return 0; - } -#endif - if (obj && !SwigPyObject_Check(obj)) { - /* a PyObject is called 'this', try to get the 'real this' - SwigPyObject from it */ - return SWIG_Python_GetSwigThis(obj); - } - return (SwigPyObject *)obj; -#endif -} - -/* Acquire a pointer value */ - -SWIGRUNTIME int -SWIG_Python_AcquirePtr(PyObject *obj, int own) { - if (own == SWIG_POINTER_OWN) { - SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); - if (sobj) { - int oldown = sobj->own; - sobj->own = own; - return oldown; - } - } - return 0; -} - -/* Convert a pointer value */ - -SWIGRUNTIME int -SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { - int res; - SwigPyObject *sobj; - int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; - - if (!obj) - return SWIG_ERROR; - if (obj == Py_None && !implicit_conv) { - if (ptr) - *ptr = 0; - return SWIG_OK; - } - - res = SWIG_ERROR; - - sobj = SWIG_Python_GetSwigThis(obj); - if (own) - *own = 0; - while (sobj) { - void *vptr = sobj->ptr; - if (ty) { - swig_type_info *to = sobj->ty; - if (to == ty) { - /* no type cast needed */ - if (ptr) *ptr = vptr; - break; - } else { - swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); - if (!tc) { - sobj = (SwigPyObject *)sobj->next; - } else { - if (ptr) { - int newmemory = 0; - *ptr = SWIG_TypeCast(tc,vptr,&newmemory); - if (newmemory == SWIG_CAST_NEW_MEMORY) { - assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ - if (own) - *own = *own | SWIG_CAST_NEW_MEMORY; - } - } - break; - } - } - } else { - if (ptr) *ptr = vptr; - break; - } - } - if (sobj) { - if (own) - *own = *own | sobj->own; - if (flags & SWIG_POINTER_DISOWN) { - sobj->own = 0; - } - res = SWIG_OK; - } else { - if (implicit_conv) { - SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; - if (data && !data->implicitconv) { - PyObject *klass = data->klass; - if (klass) { - PyObject *impconv; - data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ - impconv = SWIG_Python_CallFunctor(klass, obj); - data->implicitconv = 0; - if (PyErr_Occurred()) { - PyErr_Clear(); - impconv = 0; - } - if (impconv) { - SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); - if (iobj) { - void *vptr; - res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); - if (SWIG_IsOK(res)) { - if (ptr) { - *ptr = vptr; - /* transfer the ownership to 'ptr' */ - iobj->own = 0; - res = SWIG_AddCast(res); - res = SWIG_AddNewMask(res); - } else { - res = SWIG_AddCast(res); - } - } - } - Py_DECREF(impconv); - } - } - } - } - if (!SWIG_IsOK(res) && obj == Py_None) { - if (ptr) - *ptr = 0; - if (PyErr_Occurred()) - PyErr_Clear(); - res = SWIG_OK; - } - } - return res; -} - -/* Convert a function ptr value */ - -SWIGRUNTIME int -SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { - if (!PyCFunction_Check(obj)) { - return SWIG_ConvertPtr(obj, ptr, ty, 0); - } else { - void *vptr = 0; - - /* here we get the method pointer for callbacks */ - const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); - const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; - if (desc) - desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; - if (!desc) - return SWIG_ERROR; - if (ty) { - swig_cast_info *tc = SWIG_TypeCheck(desc,ty); - if (tc) { - int newmemory = 0; - *ptr = SWIG_TypeCast(tc,vptr,&newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ - } else { - return SWIG_ERROR; - } - } else { - *ptr = vptr; - } - return SWIG_OK; - } -} - -/* Convert a packed value value */ - -SWIGRUNTIME int -SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { - swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); - if (!to) return SWIG_ERROR; - if (ty) { - if (to != ty) { - /* check type cast? */ - swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); - if (!tc) return SWIG_ERROR; - } - } - return SWIG_OK; -} - -/* ----------------------------------------------------------------------------- - * Create a new pointer object - * ----------------------------------------------------------------------------- */ - -/* - Create a new instance object, without calling __init__, and set the - 'this' attribute. -*/ - -SWIGRUNTIME PyObject* -SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) -{ -#if (PY_VERSION_HEX >= 0x02020000) - PyObject *inst = 0; - PyObject *newraw = data->newraw; - if (newraw) { - inst = PyObject_Call(newraw, data->newargs, NULL); - if (inst) { -#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) - PyObject **dictptr = _PyObject_GetDictPtr(inst); - if (dictptr != NULL) { - PyObject *dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - PyDict_SetItem(dict, SWIG_This(), swig_this); - } - } -#else - PyObject *key = SWIG_This(); - PyObject_SetAttr(inst, key, swig_this); -#endif - } - } else { -#if PY_VERSION_HEX >= 0x03000000 - inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); - if (inst) { - PyObject_SetAttr(inst, SWIG_This(), swig_this); - Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; - } -#else - PyObject *dict = PyDict_New(); - if (dict) { - PyDict_SetItem(dict, SWIG_This(), swig_this); - inst = PyInstance_NewRaw(data->newargs, dict); - Py_DECREF(dict); - } -#endif - } - return inst; -#else -#if (PY_VERSION_HEX >= 0x02010000) - PyObject *inst = 0; - PyObject *dict = PyDict_New(); - if (dict) { - PyDict_SetItem(dict, SWIG_This(), swig_this); - inst = PyInstance_NewRaw(data->newargs, dict); - Py_DECREF(dict); - } - return (PyObject *) inst; -#else - PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); - if (inst == NULL) { - return NULL; - } - inst->in_class = (PyClassObject *)data->newargs; - Py_INCREF(inst->in_class); - inst->in_dict = PyDict_New(); - if (inst->in_dict == NULL) { - Py_DECREF(inst); - return NULL; - } -#ifdef Py_TPFLAGS_HAVE_WEAKREFS - inst->in_weakreflist = NULL; -#endif -#ifdef Py_TPFLAGS_GC - PyObject_GC_Init(inst); -#endif - PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); - return (PyObject *) inst; -#endif -#endif -} - -SWIGRUNTIME void -SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) -{ - PyObject *dict; -#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) - PyObject **dictptr = _PyObject_GetDictPtr(inst); - if (dictptr != NULL) { - dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - } - PyDict_SetItem(dict, SWIG_This(), swig_this); - return; - } -#endif - dict = PyObject_GetAttrString(inst, (char*)"__dict__"); - PyDict_SetItem(dict, SWIG_This(), swig_this); - Py_DECREF(dict); -} - - -SWIGINTERN PyObject * -SWIG_Python_InitShadowInstance(PyObject *args) { - PyObject *obj[2]; - if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { - return NULL; - } else { - SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); - if (sthis) { - SwigPyObject_append((PyObject*) sthis, obj[1]); - } else { - SWIG_Python_SetSwigThis(obj[0], obj[1]); - } - return SWIG_Py_Void(); - } -} - -/* Create a new pointer object */ - -SWIGRUNTIME PyObject * -SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { - SwigPyClientData *clientdata; - PyObject * robj; - int own; - - if (!ptr) - return SWIG_Py_Void(); - - clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; - own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; - if (clientdata && clientdata->pytype) { - SwigPyObject *newobj; - if (flags & SWIG_BUILTIN_TP_INIT) { - newobj = (SwigPyObject*) self; - if (newobj->ptr) { - PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); - while (newobj->next) - newobj = (SwigPyObject *) newobj->next; - newobj->next = next_self; - newobj = (SwigPyObject *)next_self; -#ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; -#endif - } - } else { - newobj = PyObject_New(SwigPyObject, clientdata->pytype); -#ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; -#endif - } - if (newobj) { - newobj->ptr = ptr; - newobj->ty = type; - newobj->own = own; - newobj->next = 0; - return (PyObject*) newobj; - } - return SWIG_Py_Void(); - } - - assert(!(flags & SWIG_BUILTIN_TP_INIT)); - - robj = SwigPyObject_New(ptr, type, own); - if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { - PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); - Py_DECREF(robj); - robj = inst; - } - return robj; -} - -/* Create a new packed object */ - -SWIGRUNTIMEINLINE PyObject * -SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { - return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); -} - -/* -----------------------------------------------------------------------------* - * Get type list - * -----------------------------------------------------------------------------*/ - -#ifdef SWIG_LINK_RUNTIME -void *SWIG_ReturnGlobalTypeList(void *); -#endif - -SWIGRUNTIME swig_module_info * -SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { - static void *type_pointer = (void *)0; - /* first check if module already created */ - if (!type_pointer) { -#ifdef SWIG_LINK_RUNTIME - type_pointer = SWIG_ReturnGlobalTypeList((void *)0); -#else -# ifdef SWIGPY_USE_CAPSULE - type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); -# else - type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, - (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); -# endif - if (PyErr_Occurred()) { - PyErr_Clear(); - type_pointer = (void *)0; - } -#endif - } - return (swig_module_info *) type_pointer; -} - -#if PY_MAJOR_VERSION < 2 -/* PyModule_AddObject function was introduced in Python 2.0. The following function - is copied out of Python/modsupport.c in python version 2.3.4 */ -SWIGINTERN int -PyModule_AddObject(PyObject *m, char *name, PyObject *o) -{ - PyObject *dict; - if (!PyModule_Check(m)) { - PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); - return SWIG_ERROR; - } - if (!o) { - PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); - return SWIG_ERROR; - } - - dict = PyModule_GetDict(m); - if (dict == NULL) { - /* Internal error -- modules must have a dict! */ - PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", - PyModule_GetName(m)); - return SWIG_ERROR; - } - if (PyDict_SetItemString(dict, name, o)) - return SWIG_ERROR; - Py_DECREF(o); - return SWIG_OK; -} -#endif - -SWIGRUNTIME void -#ifdef SWIGPY_USE_CAPSULE -SWIG_Python_DestroyModule(PyObject *obj) -#else -SWIG_Python_DestroyModule(void *vptr) -#endif -{ -#ifdef SWIGPY_USE_CAPSULE - swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); -#else - swig_module_info *swig_module = (swig_module_info *) vptr; -#endif - swig_type_info **types = swig_module->types; - size_t i; - for (i =0; i < swig_module->size; ++i) { - swig_type_info *ty = types[i]; - if (ty->owndata) { - SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; - if (data) SwigPyClientData_Del(data); - } - } - Py_DECREF(SWIG_This()); - swig_this = NULL; -} - -SWIGRUNTIME void -SWIG_Python_SetModule(swig_module_info *swig_module) { -#if PY_VERSION_HEX >= 0x03000000 - /* Add a dummy module object into sys.modules */ - PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); -#else - static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ - PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); -#endif -#ifdef SWIGPY_USE_CAPSULE - PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); - if (pointer && module) { - PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); - } else { - Py_XDECREF(pointer); - } -#else - PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); - if (pointer && module) { - PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); - } else { - Py_XDECREF(pointer); - } -#endif -} - -/* The python cached type query */ -SWIGRUNTIME PyObject * -SWIG_Python_TypeCache(void) { - static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); - return cache; -} - -SWIGRUNTIME swig_type_info * -SWIG_Python_TypeQuery(const char *type) -{ - PyObject *cache = SWIG_Python_TypeCache(); - PyObject *key = SWIG_Python_str_FromChar(type); - PyObject *obj = PyDict_GetItem(cache, key); - swig_type_info *descriptor; - if (obj) { -#ifdef SWIGPY_USE_CAPSULE - descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); -#else - descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); -#endif - } else { - swig_module_info *swig_module = SWIG_GetModule(0); - descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); - if (descriptor) { -#ifdef SWIGPY_USE_CAPSULE - obj = PyCapsule_New((void*) descriptor, NULL, NULL); -#else - obj = PyCObject_FromVoidPtr(descriptor, NULL); -#endif - PyDict_SetItem(cache, key, obj); - Py_DECREF(obj); - } - } - Py_DECREF(key); - return descriptor; -} - -/* - For backward compatibility only -*/ -#define SWIG_POINTER_EXCEPTION 0 -#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) -#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) - -SWIGRUNTIME int -SWIG_Python_AddErrMesg(const char* mesg, int infront) -{ - if (PyErr_Occurred()) { - PyObject *type = 0; - PyObject *value = 0; - PyObject *traceback = 0; - PyErr_Fetch(&type, &value, &traceback); - if (value) { - char *tmp; - PyObject *old_str = PyObject_Str(value); - Py_XINCREF(type); - PyErr_Clear(); - if (infront) { - PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); - } else { - PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); - } - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); - } - return 1; - } else { - return 0; - } -} - -SWIGRUNTIME int -SWIG_Python_ArgFail(int argnum) -{ - if (PyErr_Occurred()) { - /* add information about failing argument */ - char mesg[256]; - PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); - return SWIG_Python_AddErrMesg(mesg, 1); - } else { - return 0; - } -} - -SWIGRUNTIMEINLINE const char * -SwigPyObject_GetDesc(PyObject *self) -{ - SwigPyObject *v = (SwigPyObject *)self; - swig_type_info *ty = v ? v->ty : 0; - return ty ? ty->str : ""; -} - -SWIGRUNTIME void -SWIG_Python_TypeError(const char *type, PyObject *obj) -{ - if (type) { -#if defined(SWIG_COBJECT_TYPES) - if (obj && SwigPyObject_Check(obj)) { - const char *otype = (const char *) SwigPyObject_GetDesc(obj); - if (otype) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", - type, otype); - return; - } - } else -#endif - { - const char *otype = (obj ? obj->ob_type->tp_name : 0); - if (otype) { - PyObject *str = PyObject_Str(obj); - const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; - if (cstr) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", - type, otype, cstr); - SWIG_Python_str_DelForPy3(cstr); - } else { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", - type, otype); - } - Py_XDECREF(str); - return; - } - } - PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); - } else { - PyErr_Format(PyExc_TypeError, "unexpected type is received"); - } -} - - -/* Convert a pointer value, signal an exception on a type mismatch */ -SWIGRUNTIME void * -SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { - void *result; - if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { - PyErr_Clear(); -#if SWIG_POINTER_EXCEPTION - if (flags) { - SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); - SWIG_Python_ArgFail(argnum); - } -#endif - } - return result; -} - -#ifdef SWIGPYTHON_BUILTIN -SWIGRUNTIME int -SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { - PyTypeObject *tp = obj->ob_type; - PyObject *descr; - PyObject *encoded_name; - descrsetfunc f; - int res = -1; - -# ifdef Py_USING_UNICODE - if (PyString_Check(name)) { - name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); - if (!name) - return -1; - } else if (!PyUnicode_Check(name)) -# else - if (!PyString_Check(name)) -# endif - { - PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); - return -1; - } else { - Py_INCREF(name); - } - - if (!tp->tp_dict) { - if (PyType_Ready(tp) < 0) - goto done; - } - - descr = _PyType_Lookup(tp, name); - f = NULL; - if (descr != NULL) - f = descr->ob_type->tp_descr_set; - if (!f) { - if (PyString_Check(name)) { - encoded_name = name; - Py_INCREF(name); - } else { - encoded_name = PyUnicode_AsUTF8String(name); - } - PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); - Py_DECREF(encoded_name); - } else { - res = f(descr, obj, value); - } - - done: - Py_DECREF(name); - return res; -} -#endif - - -#ifdef __cplusplus -} -#endif - - - -#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) - -#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else - - - - #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) - -/* ----------------------------------------------------------------------------- - * director_common.swg - * - * This file contains support for director classes which is common between - * languages. - * ----------------------------------------------------------------------------- */ - -/* - Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the - 'Swig' namespace. This could be useful for multi-modules projects. -*/ -#ifdef SWIG_DIRECTOR_STATIC -/* Force anonymous (static) namespace */ -#define Swig -#endif -/* ----------------------------------------------------------------------------- - * director.swg - * - * This file contains support for director classes so that Python proxy - * methods can be called from C++. - * ----------------------------------------------------------------------------- */ - -#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ -#define SWIG_DIRECTOR_PYTHON_HEADER_ - -#include -#include -#include -#include -#include - - -/* - Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual - table', and avoid multiple GetAttr calls to retrieve the python - methods. -*/ - -#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE -#ifndef SWIG_PYTHON_DIRECTOR_VTABLE -#define SWIG_PYTHON_DIRECTOR_VTABLE -#endif -#endif - - - -/* - Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the - Undefined Exception Handler provided by swig. -*/ -#ifndef SWIG_DIRECTOR_NO_UEH -#ifndef SWIG_DIRECTOR_UEH -#define SWIG_DIRECTOR_UEH -#endif -#endif - - -/* - Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the - native C++ RTTI and dynamic_cast<>. But be aware that directors - could stop working when using this option. -*/ -#ifdef SWIG_DIRECTOR_NORTTI -/* - When we don't use the native C++ RTTI, we implement a minimal one - only for Directors. -*/ -# ifndef SWIG_DIRECTOR_RTDIR -# define SWIG_DIRECTOR_RTDIR - -namespace Swig { - class Director; - SWIGINTERN std::map& get_rtdir_map() { - static std::map rtdir_map; - return rtdir_map; - } - - SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { - get_rtdir_map()[vptr] = rtdir; - } - - SWIGINTERNINLINE Director *get_rtdir(void *vptr) { - std::map::const_iterator pos = get_rtdir_map().find(vptr); - Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; - return rtdir; - } -} -# endif /* SWIG_DIRECTOR_RTDIR */ - -# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) -# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) - -#else - -# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) -# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) - -#endif /* SWIG_DIRECTOR_NORTTI */ - -extern "C" { - struct swig_type_info; -} - -namespace Swig { - - /* memory handler */ - struct GCItem { - virtual ~GCItem() {} - - virtual int get_own() const { - return 0; - } - }; - - struct GCItem_var { - GCItem_var(GCItem *item = 0) : _item(item) { - } - - GCItem_var& operator=(GCItem *item) { - GCItem *tmp = _item; - _item = item; - delete tmp; - return *this; - } - - ~GCItem_var() { - delete _item; - } - - GCItem * operator->() const { - return _item; - } - - private: - GCItem *_item; - }; - - struct GCItem_Object : GCItem { - GCItem_Object(int own) : _own(own) { - } - - virtual ~GCItem_Object() { - } - - int get_own() const { - return _own; - } - - private: - int _own; - }; - - template - struct GCItem_T : GCItem { - GCItem_T(Type *ptr) : _ptr(ptr) { - } - - virtual ~GCItem_T() { - delete _ptr; - } - - private: - Type *_ptr; - }; - - template - struct GCArray_T : GCItem { - GCArray_T(Type *ptr) : _ptr(ptr) { - } - - virtual ~GCArray_T() { - delete[] _ptr; - } - - private: - Type *_ptr; - }; - - /* base class for director exceptions */ - class DirectorException : public std::exception { - protected: - std::string swig_msg; - public: - DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - if (msg[0]) { - swig_msg += " "; - swig_msg += msg; - } - if (!PyErr_Occurred()) { - PyErr_SetString(error, what()); - } - SWIG_PYTHON_THREAD_END_BLOCK; - } - - virtual ~DirectorException() throw() { - } - - /* Deprecated, use what() instead */ - const char *getMessage() const { - return what(); - } - - const char *what() const throw() { - return swig_msg.c_str(); - } - - static void raise(PyObject *error, const char *msg) { - throw DirectorException(error, msg); - } - - static void raise(const char *msg) { - raise(PyExc_RuntimeError, msg); - } - }; - - /* unknown exception handler */ - class UnknownExceptionHandler { -#ifdef SWIG_DIRECTOR_UEH - static void handler() { - try { - throw; - } catch (DirectorException& e) { - std::cerr << "SWIG Director exception caught:" << std::endl - << e.what() << std::endl; - } catch (std::exception& e) { - std::cerr << "std::exception caught: "<< e.what() << std::endl; - } catch (...) { - std::cerr << "Unknown exception caught." << std::endl; - } - - std::cerr << std::endl - << "Python interpreter traceback:" << std::endl; - PyErr_Print(); - std::cerr << std::endl; - - std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl - << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl - << std::endl - << "Exception is being re-thrown, program will likely abort/terminate." << std::endl; - throw; - } - - public: - - std::unexpected_handler old; - UnknownExceptionHandler(std::unexpected_handler nh = handler) { - old = std::set_unexpected(nh); - } - - ~UnknownExceptionHandler() { - std::set_unexpected(old); - } -#endif - }; - - /* type mismatch in the return value from a python method call */ - class DirectorTypeMismatchException : public DirectorException { - public: - DirectorTypeMismatchException(PyObject *error, const char *msg="") - : DirectorException(error, "SWIG director type mismatch", msg) { - } - - DirectorTypeMismatchException(const char *msg="") - : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { - } - - static void raise(PyObject *error, const char *msg) { - throw DirectorTypeMismatchException(error, msg); - } - - static void raise(const char *msg) { - throw DirectorTypeMismatchException(msg); - } - }; - - /* any python exception that occurs during a director method call */ - class DirectorMethodException : public DirectorException { - public: - DirectorMethodException(const char *msg = "") - : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { - } - - static void raise(const char *msg) { - throw DirectorMethodException(msg); - } - }; - - /* attempt to call a pure virtual method via a director method */ - class DirectorPureVirtualException : public DirectorException { - public: - DirectorPureVirtualException(const char *msg = "") - : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { - } - - static void raise(const char *msg) { - throw DirectorPureVirtualException(msg); - } - }; - - -#if defined(SWIG_PYTHON_THREADS) -/* __THREAD__ is the old macro to activate some thread support */ -# if !defined(__THREAD__) -# define __THREAD__ 1 -# endif -#endif - -#ifdef __THREAD__ -# include "pythread.h" - class Guard { - PyThread_type_lock &mutex_; - - public: - Guard(PyThread_type_lock & mutex) : mutex_(mutex) { - PyThread_acquire_lock(mutex_, WAIT_LOCK); - } - - ~Guard() { - PyThread_release_lock(mutex_); - } - }; -# define SWIG_GUARD(mutex) Guard _guard(mutex) -#else -# define SWIG_GUARD(mutex) -#endif - - /* director base class */ - class Director { - private: - /* pointer to the wrapped python object */ - PyObject *swig_self; - /* flag indicating whether the object is owned by python or c++ */ - mutable bool swig_disown_flag; - - /* decrement the reference count of the wrapped python object */ - void swig_decref() const { - if (swig_disown_flag) { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_DECREF(swig_self); - SWIG_PYTHON_THREAD_END_BLOCK; - } - } - - public: - /* wrap a python object. */ - Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { - } - - /* discard our reference at destruction */ - virtual ~Director() { - swig_decref(); - } - - /* return a pointer to the wrapped python object */ - PyObject *swig_get_self() const { - return swig_self; - } - - /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ - void swig_disown() const { - if (!swig_disown_flag) { - swig_disown_flag=true; - swig_incref(); - } - } - - /* increase the reference count of the wrapped python object */ - void swig_incref() const { - if (swig_disown_flag) { - Py_INCREF(swig_self); - } - } - - /* methods to implement pseudo protected director members */ - virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { - return true; - } - - virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { - } - - /* ownership management */ - private: - typedef std::map swig_ownership_map; - mutable swig_ownership_map swig_owner; -#ifdef __THREAD__ - static PyThread_type_lock swig_mutex_own; -#endif - - public: - template - void swig_acquire_ownership_array(Type *vptr) const { - if (vptr) { - SWIG_GUARD(swig_mutex_own); - swig_owner[vptr] = new GCArray_T(vptr); - } - } - - template - void swig_acquire_ownership(Type *vptr) const { - if (vptr) { - SWIG_GUARD(swig_mutex_own); - swig_owner[vptr] = new GCItem_T(vptr); - } - } - - void swig_acquire_ownership_obj(void *vptr, int own) const { - if (vptr && own) { - SWIG_GUARD(swig_mutex_own); - swig_owner[vptr] = new GCItem_Object(own); - } - } - - int swig_release_ownership(void *vptr) const { - int own = 0; - if (vptr) { - SWIG_GUARD(swig_mutex_own); - swig_ownership_map::iterator iter = swig_owner.find(vptr); - if (iter != swig_owner.end()) { - own = iter->second->get_own(); - swig_owner.erase(iter); - } - } - return own; - } - - template - static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { - SwigPyObject *sobj = (SwigPyObject *)pyobj; - sobj->own = 0; - Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); - if (d) - d->swig_disown(); - return PyWeakref_NewProxy(pyobj, NULL); - } - }; - -#ifdef __THREAD__ - PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock(); -#endif -} - -#endif - -/* -------- TYPES TABLE (BEGIN) -------- */ - -#define SWIGTYPE_p_FractalMarker swig_types[0] -#define SWIGTYPE_p_FractalMarkerSet swig_types[1] -#define SWIGTYPE_p_FractalMarkerSet__CONF_TYPES swig_types[2] -#define SWIGTYPE_p_Marker swig_types[3] -#define SWIGTYPE_p_allocator_type swig_types[4] -#define SWIGTYPE_p_aruco__CameraParameters swig_types[5] -#define SWIGTYPE_p_aruco__CvDrawingUtils swig_types[6] -#define SWIGTYPE_p_aruco__Debug swig_types[7] -#define SWIGTYPE_p_aruco__Dictionary swig_types[8] -#define SWIGTYPE_p_aruco__FractalDetector swig_types[9] -#define SWIGTYPE_p_aruco__FractalMarker swig_types[10] -#define SWIGTYPE_p_aruco__FractalMarkerLabeler swig_types[11] -#define SWIGTYPE_p_aruco__FractalMarkerSet swig_types[12] -#define SWIGTYPE_p_aruco__FractalPoseTracker swig_types[13] -#define SWIGTYPE_p_aruco__Marker swig_types[14] -#define SWIGTYPE_p_aruco__Marker3DInfo swig_types[15] -#define SWIGTYPE_p_aruco__MarkerDetector swig_types[16] -#define SWIGTYPE_p_aruco__MarkerDetector__Params swig_types[17] -#define SWIGTYPE_p_aruco__MarkerLabeler swig_types[18] -#define SWIGTYPE_p_aruco__MarkerMap swig_types[19] -#define SWIGTYPE_p_aruco__MarkerMapPoseTracker swig_types[20] -#define SWIGTYPE_p_aruco__MarkerPoseTracker swig_types[21] -#define SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter swig_types[22] -#define SWIGTYPE_p_aruco__ScopeTimer swig_types[23] -#define SWIGTYPE_p_aruco__ScopedTimerEvents swig_types[24] -#define SWIGTYPE_p_aruco__Timer swig_types[25] -#define SWIGTYPE_p_char swig_types[26] -#define SWIGTYPE_p_cv__FileStorage swig_types[27] -#define SWIGTYPE_p_cv__KeyPoint swig_types[28] -#define SWIGTYPE_p_cv__Point2f swig_types[29] -#define SWIGTYPE_p_cv__Point3f swig_types[30] -#define SWIGTYPE_p_cv__PtrT_aruco__FractalMarkerLabeler_t swig_types[31] -#define SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t swig_types[32] -#define SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t swig_types[33] -#define SWIGTYPE_p_cv__Size swig_types[34] -#define SWIGTYPE_p_difference_type swig_types[35] -#define SWIGTYPE_p_double swig_types[36] -#define SWIGTYPE_p_float swig_types[37] -#define SWIGTYPE_p_int swig_types[38] -#define SWIGTYPE_p_p_PyObject swig_types[39] -#define SWIGTYPE_p_size_type swig_types[40] -#define SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t swig_types[41] -#define SWIGTYPE_p_std__allocatorT_aruco__Marker_t swig_types[42] -#define SWIGTYPE_p_std__allocatorT_cv__Point2f_t swig_types[43] -#define SWIGTYPE_p_std__allocatorT_int_t swig_types[44] -#define SWIGTYPE_p_std__chrono__high_resolution_clock__time_point swig_types[45] -#define SWIGTYPE_p_std__invalid_argument swig_types[46] -#define SWIGTYPE_p_std__istream swig_types[47] -#define SWIGTYPE_p_std__mapT_int_FractalMarker_t swig_types[48] -#define SWIGTYPE_p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t swig_types[49] -#define SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[50] -#define SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t swig_types[51] -#define SWIGTYPE_p_std__ostream swig_types[52] -#define SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t swig_types[53] -#define SWIGTYPE_p_std__string swig_types[54] -#define SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t swig_types[55] -#define SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t swig_types[56] -#define SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t swig_types[57] -#define SWIGTYPE_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t swig_types[58] -#define SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t swig_types[59] -#define SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t swig_types[60] -#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[61] -#define SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t swig_types[62] -#define SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t swig_types[63] -#define SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t swig_types[64] -#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[65] -#define SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t swig_types[66] -#define SWIGTYPE_p_swig__SwigPyIterator swig_types[67] -#define SWIGTYPE_p_uint32_t swig_types[68] -#define SWIGTYPE_p_uint64_t swig_types[69] -#define SWIGTYPE_p_value_type swig_types[70] -#define SWIGTYPE_p_vectorT_aruco__Marker_t swig_types[71] -#define SWIGTYPE_p_vectorT_cv__Point3f_t swig_types[72] -#define SWIGTYPE_p_vectorT_cv__Point_t swig_types[73] -#define SWIGTYPE_p_vectorT_int_t swig_types[74] -static swig_type_info *swig_types[76]; -static swig_module_info swig_module = {swig_types, 75, 0, 0, 0, 0}; -#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) -#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) - -/* -------- TYPES TABLE (END) -------- */ - -#if (PY_VERSION_HEX <= 0x02000000) -# if !defined(SWIG_PYTHON_CLASSIC) -# error "This python version requires swig to be run with the '-classic' option" -# endif -#endif - -/*----------------------------------------------- - @(target):= _aruco.so - ------------------------------------------------*/ -#if PY_VERSION_HEX >= 0x03000000 -# define SWIG_init PyInit__aruco - -#else -# define SWIG_init init_aruco - -#endif -#define SWIG_name "_aruco" - -#define SWIGVERSION 0x030012 -#define SWIG_VERSION SWIGVERSION - - -#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) -#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) - - -#include - - -namespace swig { - class SwigPtr_PyObject { - protected: - PyObject *_obj; - - public: - SwigPtr_PyObject() :_obj(0) - { - } - - SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_XINCREF(_obj); - SWIG_PYTHON_THREAD_END_BLOCK; - } - - SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) - { - if (initial_ref) { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_XINCREF(_obj); - SWIG_PYTHON_THREAD_END_BLOCK; - } - } - - SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_XINCREF(item._obj); - Py_XDECREF(_obj); - _obj = item._obj; - SWIG_PYTHON_THREAD_END_BLOCK; - return *this; - } - - ~SwigPtr_PyObject() - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_XDECREF(_obj); - SWIG_PYTHON_THREAD_END_BLOCK; - } - - operator PyObject *() const - { - return _obj; - } - - PyObject *operator->() const - { - return _obj; - } - }; -} - - -namespace swig { - struct SwigVar_PyObject : SwigPtr_PyObject { - SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } - - SwigVar_PyObject & operator = (PyObject* obj) - { - Py_XDECREF(_obj); - _obj = obj; - return *this; - } - }; -} - - -#include - - -#include - -#if PY_VERSION_HEX >= 0x03020000 -# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj)) -#else -# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj)) -#endif - - -#include -#include - - -#if defined(__GNUC__) -# if __GNUC__ == 2 && __GNUC_MINOR <= 96 -# define SWIG_STD_NOMODERN_STL -# endif -#endif - - -#include - - -namespace swig { - struct stop_iteration { - }; - - struct SwigPyIterator { - private: - SwigPtr_PyObject _seq; - - protected: - SwigPyIterator(PyObject *seq) : _seq(seq) - { - } - - public: - virtual ~SwigPyIterator() {} - - // Access iterator method, required by Python - virtual PyObject *value() const = 0; - - // Forward iterator method, required by Python - virtual SwigPyIterator *incr(size_t n = 1) = 0; - - // Backward iterator method, very common in C++, but not required in Python - virtual SwigPyIterator *decr(size_t /*n*/ = 1) - { - throw stop_iteration(); - } - - // Random access iterator methods, but not required in Python - virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const - { - throw std::invalid_argument("operation not supported"); - } - - virtual bool equal (const SwigPyIterator &/*x*/) const - { - throw std::invalid_argument("operation not supported"); - } - - // C++ common/needed methods - virtual SwigPyIterator *copy() const = 0; - - PyObject *next() - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads - PyObject *obj = value(); - incr(); - SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads - return obj; - } - - /* Make an alias for Python 3.x */ - PyObject *__next__() - { - return next(); - } - - PyObject *previous() - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads - decr(); - PyObject *obj = value(); - SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads - return obj; - } - - SwigPyIterator *advance(ptrdiff_t n) - { - return (n > 0) ? incr(n) : decr(-n); - } - - bool operator == (const SwigPyIterator& x) const - { - return equal(x); - } - - bool operator != (const SwigPyIterator& x) const - { - return ! operator==(x); - } - - SwigPyIterator& operator += (ptrdiff_t n) - { - return *advance(n); - } - - SwigPyIterator& operator -= (ptrdiff_t n) - { - return *advance(-n); - } - - SwigPyIterator* operator + (ptrdiff_t n) const - { - return copy()->advance(n); - } - - SwigPyIterator* operator - (ptrdiff_t n) const - { - return copy()->advance(-n); - } - - ptrdiff_t operator - (const SwigPyIterator& x) const - { - return x.distance(*this); - } - - static swig_type_info* descriptor() { - static int init = 0; - static swig_type_info* desc = 0; - if (!init) { - desc = SWIG_TypeQuery("swig::SwigPyIterator *"); - init = 1; - } - return desc; - } - }; - -#if defined(SWIGPYTHON_BUILTIN) - inline PyObject* make_output_iterator_builtin (PyObject *pyself) - { - Py_INCREF(pyself); - return pyself; - } -#endif -} - - -SWIGINTERN int -SWIG_AsVal_double (PyObject *obj, double *val) -{ - int res = SWIG_TypeError; - if (PyFloat_Check(obj)) { - if (val) *val = PyFloat_AsDouble(obj); - return SWIG_OK; -#if PY_VERSION_HEX < 0x03000000 - } else if (PyInt_Check(obj)) { - if (val) *val = (double) PyInt_AsLong(obj); - return SWIG_OK; -#endif - } else if (PyLong_Check(obj)) { - double v = PyLong_AsDouble(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - double d = PyFloat_AsDouble(obj); - if (!PyErr_Occurred()) { - if (val) *val = d; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); - } - if (!dispatch) { - long v = PyLong_AsLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); - } else { - PyErr_Clear(); - } - } - } -#endif - return res; -} - - -#include - - -#include - - -SWIGINTERNINLINE int -SWIG_CanCastAsInteger(double *d, double min, double max) { - double x = *d; - if ((min <= x && x <= max)) { - double fx = floor(x); - double cx = ceil(x); - double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ - if ((errno == EDOM) || (errno == ERANGE)) { - errno = 0; - } else { - double summ, reps, diff; - if (rd < x) { - diff = x - rd; - } else if (rd > x) { - diff = rd - x; - } else { - return 1; - } - summ = rd + x; - reps = diff/summ; - if (reps < 8*DBL_EPSILON) { - *d = rd; - return 1; - } - } - } - return 0; -} - - -SWIGINTERN int -SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) -{ -#if PY_VERSION_HEX < 0x03000000 - if (PyInt_Check(obj)) { - long v = PyInt_AsLong(obj); - if (v >= 0) { - if (val) *val = v; - return SWIG_OK; - } else { - return SWIG_OverflowError; - } - } else -#endif - if (PyLong_Check(obj)) { - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - return SWIG_OverflowError; - } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); - } - if (!dispatch) { - double d; - int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { - if (val) *val = (unsigned long)(d); - return res; - } - } - } -#endif - return SWIG_TypeError; -} - - -#include -#if !defined(SWIG_NO_LLONG_MAX) -# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) -# define LLONG_MAX __LONG_LONG_MAX__ -# define LLONG_MIN (-LLONG_MAX - 1LL) -# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) -# endif -#endif - - -#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE) -# define SWIG_LONG_LONG_AVAILABLE -#endif - - -#ifdef SWIG_LONG_LONG_AVAILABLE -SWIGINTERN int -SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val) -{ - int res = SWIG_TypeError; - if (PyLong_Check(obj)) { - unsigned long long v = PyLong_AsUnsignedLongLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - res = SWIG_OverflowError; - } - } else { - unsigned long v; - res = SWIG_AsVal_unsigned_SS_long (obj,&v); - if (SWIG_IsOK(res)) { - if (val) *val = v; - return res; - } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - const double mant_max = 1LL << DBL_MANT_DIG; - double d; - res = SWIG_AsVal_double (obj,&d); - if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max)) - return SWIG_OverflowError; - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) { - if (val) *val = (unsigned long long)(d); - return SWIG_AddCast(res); - } - res = SWIG_TypeError; - } -#endif - return res; -} -#endif - - -SWIGINTERNINLINE int -SWIG_AsVal_size_t (PyObject * obj, size_t *val) -{ - int res = SWIG_TypeError; -#ifdef SWIG_LONG_LONG_AVAILABLE - if (sizeof(size_t) <= sizeof(unsigned long)) { -#endif - unsigned long v; - res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); - if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); -#ifdef SWIG_LONG_LONG_AVAILABLE - } else if (sizeof(size_t) <= sizeof(unsigned long long)) { - unsigned long long v; - res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0); - if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); - } -#endif - return res; -} - - - #define SWIG_From_long PyInt_FromLong - - -#ifdef SWIG_LONG_LONG_AVAILABLE -SWIGINTERNINLINE PyObject* -SWIG_From_long_SS_long (long long value) -{ - return ((value < LONG_MIN) || (value > LONG_MAX)) ? - PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value)); -} -#endif - - -SWIGINTERNINLINE PyObject * -SWIG_From_ptrdiff_t (ptrdiff_t value) -{ -#ifdef SWIG_LONG_LONG_AVAILABLE - if (sizeof(ptrdiff_t) <= sizeof(long)) { -#endif - return SWIG_From_long (static_cast< long >(value)); -#ifdef SWIG_LONG_LONG_AVAILABLE - } else { - /* assume sizeof(ptrdiff_t) <= sizeof(long long) */ - return SWIG_From_long_SS_long (static_cast< long long >(value)); - } -#endif -} - - -SWIGINTERNINLINE PyObject* - SWIG_From_bool (bool value) -{ - return PyBool_FromLong(value ? 1 : 0); -} - - -SWIGINTERN int -SWIG_AsVal_long (PyObject *obj, long* val) -{ -#if PY_VERSION_HEX < 0x03000000 - if (PyInt_Check(obj)) { - if (val) *val = PyInt_AsLong(obj); - return SWIG_OK; - } else -#endif - if (PyLong_Check(obj)) { - long v = PyLong_AsLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - return SWIG_OverflowError; - } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - long v = PyInt_AsLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); - } - if (!dispatch) { - double d; - int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { - if (val) *val = (long)(d); - return res; - } - } - } -#endif - return SWIG_TypeError; -} - - -#ifdef SWIG_LONG_LONG_AVAILABLE -SWIGINTERN int -SWIG_AsVal_long_SS_long (PyObject *obj, long long *val) -{ - int res = SWIG_TypeError; - if (PyLong_Check(obj)) { - long long v = PyLong_AsLongLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - res = SWIG_OverflowError; - } - } else { - long v; - res = SWIG_AsVal_long (obj,&v); - if (SWIG_IsOK(res)) { - if (val) *val = v; - return res; - } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - const double mant_max = 1LL << DBL_MANT_DIG; - const double mant_min = -mant_max; - double d; - res = SWIG_AsVal_double (obj,&d); - if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max)) - return SWIG_OverflowError; - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) { - if (val) *val = (long long)(d); - return SWIG_AddCast(res); - } - res = SWIG_TypeError; - } -#endif - return res; -} -#endif - - -SWIGINTERNINLINE int -SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val) -{ - int res = SWIG_TypeError; -#ifdef SWIG_LONG_LONG_AVAILABLE - if (sizeof(ptrdiff_t) <= sizeof(long)) { -#endif - long v; - res = SWIG_AsVal_long (obj, val ? &v : 0); - if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); -#ifdef SWIG_LONG_LONG_AVAILABLE - } else if (sizeof(ptrdiff_t) <= sizeof(long long)) { - long long v; - res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0); - if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); - } -#endif - return res; -} - - -#include - - -#include - - - #define SWIG_FILE_WITH_INIT - using namespace std; - - -namespace swig { - template - struct noconst_traits { - typedef Type noconst_type; - }; - - template - struct noconst_traits { - typedef Type noconst_type; - }; - - /* - type categories - */ - struct pointer_category { }; - struct value_category { }; - - /* - General traits that provides type_name and type_info - */ - template struct traits { }; - - template - inline const char* type_name() { - return traits::noconst_type >::type_name(); - } - - template struct traits_info { - static swig_type_info *type_query(std::string name) { - name += " *"; - return SWIG_TypeQuery(name.c_str()); - } - static swig_type_info *type_info() { - static swig_type_info *info = type_query(type_name()); - return info; - } - }; - - /* - Partial specialization for pointers (traits_info) - */ - template struct traits_info { - static swig_type_info *type_query(std::string name) { - name += " *"; - return SWIG_TypeQuery(name.c_str()); - } - static swig_type_info *type_info() { - static swig_type_info *info = type_query(type_name()); - return info; - } - }; - - template - inline swig_type_info *type_info() { - return traits_info::type_info(); - } - - /* - Partial specialization for pointers (traits) - */ - template struct traits { - typedef pointer_category category; - static std::string make_ptr_name(const char* name) { - std::string ptrname = name; - ptrname += " *"; - return ptrname; - } - static const char* type_name() { - static std::string name = make_ptr_name(swig::type_name()); - return name.c_str(); - } - }; - - template - struct traits_as { }; - - template - struct traits_check { }; - -} - - -namespace swig { - /* - Traits that provides the from method - */ - template struct traits_from_ptr { - static PyObject *from(Type *val, int owner = 0) { - return SWIG_InternalNewPointerObj(val, type_info(), owner); - } - }; - - template struct traits_from { - static PyObject *from(const Type& val) { - return traits_from_ptr::from(new Type(val), 1); - } - }; - - template struct traits_from { - static PyObject *from(Type* val) { - return traits_from_ptr::from(val, 0); - } - }; - - template struct traits_from { - static PyObject *from(const Type* val) { - return traits_from_ptr::from(const_cast(val), 0); - } - }; - - - template - inline PyObject *from(const Type& val) { - return traits_from::from(val); - } - - template - inline PyObject *from_ptr(Type* val, int owner) { - return traits_from_ptr::from(val, owner); - } - - /* - Traits that provides the asval/as/check method - */ - template - struct traits_asptr { - static int asptr(PyObject *obj, Type **val) { - Type *p; - swig_type_info *descriptor = type_info(); - int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR; - if (SWIG_IsOK(res)) { - if (val) *val = p; - } - return res; - } - }; - - template - inline int asptr(PyObject *obj, Type **vptr) { - return traits_asptr::asptr(obj, vptr); - } - - template - struct traits_asval { - static int asval(PyObject *obj, Type *val) { - if (val) { - Type *p = 0; - int res = traits_asptr::asptr(obj, &p); - if (!SWIG_IsOK(res)) return res; - if (p) { - typedef typename noconst_traits::noconst_type noconst_type; - *(const_cast(val)) = *p; - if (SWIG_IsNewObj(res)){ - delete p; - res = SWIG_DelNewMask(res); - } - return res; - } else { - return SWIG_ERROR; - } - } else { - return traits_asptr::asptr(obj, (Type **)(0)); - } - } - }; - - template struct traits_asval { - static int asval(PyObject *obj, Type **val) { - if (val) { - typedef typename noconst_traits::noconst_type noconst_type; - noconst_type *p = 0; - int res = traits_asptr::asptr(obj, &p); - if (SWIG_IsOK(res)) { - *(const_cast(val)) = p; - } - return res; - } else { - return traits_asptr::asptr(obj, (Type **)(0)); - } - } - }; - - template - inline int asval(PyObject *obj, Type *val) { - return traits_asval::asval(obj, val); - } - - template - struct traits_as { - static Type as(PyObject *obj, bool throw_error) { - Type v; - int res = asval(obj, &v); - if (!obj || !SWIG_IsOK(res)) { - if (!PyErr_Occurred()) { - ::SWIG_Error(SWIG_TypeError, swig::type_name()); - } - if (throw_error) throw std::invalid_argument("bad type"); - } - return v; - } - }; - - template - struct traits_as { - static Type as(PyObject *obj, bool throw_error) { - Type *v = 0; - int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); - if (SWIG_IsOK(res) && v) { - if (SWIG_IsNewObj(res)) { - Type r(*v); - delete v; - return r; - } else { - return *v; - } - } else { - // Uninitialized return value, no Type() constructor required. - static Type *v_def = (Type*) malloc(sizeof(Type)); - if (!PyErr_Occurred()) { - SWIG_Error(SWIG_TypeError, swig::type_name()); - } - if (throw_error) throw std::invalid_argument("bad type"); - memset(v_def,0,sizeof(Type)); - return *v_def; - } - } - }; - - template - struct traits_as { - static Type* as(PyObject *obj, bool throw_error) { - Type *v = 0; - int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); - if (SWIG_IsOK(res)) { - return v; - } else { - if (!PyErr_Occurred()) { - SWIG_Error(SWIG_TypeError, swig::type_name()); - } - if (throw_error) throw std::invalid_argument("bad type"); - return 0; - } - } - }; - - template - inline Type as(PyObject *obj, bool te = false) { - return traits_as::category>::as(obj, te); - } - - template - struct traits_check { - static bool check(PyObject *obj) { - int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR; - return SWIG_IsOK(res) ? true : false; - } - }; - - template - struct traits_check { - static bool check(PyObject *obj) { - int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR; - return SWIG_IsOK(res) ? true : false; - } - }; - - template - inline bool check(PyObject *obj) { - return traits_check::category>::check(obj); - } -} - - -#include - -namespace std { - template <> - struct less - { - bool - operator()(PyObject * v, PyObject *w) const - { - bool res; - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false; - /* This may fall into a case of inconsistent - eg. ObjA > ObjX > ObjB - but ObjA < ObjB - */ - if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) ) - { - /* Objects can't be compared, this mostly occurred in Python 3.0 */ - /* Compare their ptr directly for a workaround */ - res = (v < w); - PyErr_Clear(); - } - SWIG_PYTHON_THREAD_END_BLOCK; - return res; - } - }; - - template <> - struct less - { - bool - operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const - { - return std::less()(v, w); - } - }; - - template <> - struct less - { - bool - operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const - { - return std::less()(v, w); - } - }; - -} - -namespace swig { - template <> struct traits { - typedef value_category category; - static const char* type_name() { return "PyObject *"; } - }; - - template <> struct traits_asval { - typedef PyObject * value_type; - static int asval(PyObject *obj, value_type *val) { - if (val) *val = obj; - return SWIG_OK; - } - }; - - template <> - struct traits_check { - static bool check(PyObject *) { - return true; - } - }; - - template <> struct traits_from { - typedef PyObject * value_type; - static PyObject *from(const value_type& val) { - Py_XINCREF(val); - return val; - } - }; - -} - -namespace swig { - template - inline size_t - check_index(Difference i, size_t size, bool insert = false) { - if ( i < 0 ) { - if ((size_t) (-i) <= size) - return (size_t) (i + size); - } else if ( (size_t) i < size ) { - return (size_t) i; - } else if (insert && ((size_t) i == size)) { - return size; - } - throw std::out_of_range("index out of range"); - } - - template - void - slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) { - if (step == 0) { - throw std::invalid_argument("slice step cannot be zero"); - } else if (step > 0) { - // Required range: 0 <= i < size, 0 <= j < size, i <= j - if (i < 0) { - ii = 0; - } else if (i < (Difference)size) { - ii = i; - } else if (insert && (i >= (Difference)size)) { - ii = (Difference)size; - } - if (j < 0) { - jj = 0; - } else { - jj = (j < (Difference)size) ? j : (Difference)size; - } - if (jj < ii) - jj = ii; - } else { - // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j - if (i < -1) { - ii = -1; - } else if (i < (Difference) size) { - ii = i; - } else if (i >= (Difference)(size-1)) { - ii = (Difference)(size-1); - } - if (j < -1) { - jj = -1; - } else { - jj = (j < (Difference)size ) ? j : (Difference)(size-1); - } - if (ii < jj) - ii = jj; - } - } - - template - inline typename Sequence::iterator - getpos(Sequence* self, Difference i) { - typename Sequence::iterator pos = self->begin(); - std::advance(pos, check_index(i,self->size())); - return pos; - } - - template - inline typename Sequence::const_iterator - cgetpos(const Sequence* self, Difference i) { - typename Sequence::const_iterator pos = self->begin(); - std::advance(pos, check_index(i,self->size())); - return pos; - } - - template - inline void - erase(Sequence* seq, const typename Sequence::iterator& position) { - seq->erase(position); - } - - template - struct traits_reserve { - static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) { - // This should be specialized for types that support reserve - } - }; - - template - inline Sequence* - getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) { - typename Sequence::size_type size = self->size(); - Difference ii = 0; - Difference jj = 0; - swig::slice_adjust(i, j, step, size, ii, jj); - - if (step > 0) { - typename Sequence::const_iterator sb = self->begin(); - typename Sequence::const_iterator se = self->begin(); - std::advance(sb,ii); - std::advance(se,jj); - if (step == 1) { - return new Sequence(sb, se); - } else { - Sequence *sequence = new Sequence(); - swig::traits_reserve::reserve(*sequence, (jj - ii + step - 1) / step); - typename Sequence::const_iterator it = sb; - while (it!=se) { - sequence->push_back(*it); - for (Py_ssize_t c=0; c::reserve(*sequence, (ii - jj - step - 1) / -step); - typename Sequence::const_reverse_iterator sb = self->rbegin(); - typename Sequence::const_reverse_iterator se = self->rbegin(); - std::advance(sb,size-ii-1); - std::advance(se,size-jj-1); - typename Sequence::const_reverse_iterator it = sb; - while (it!=se) { - sequence->push_back(*it); - for (Py_ssize_t c=0; c<-step && it!=se; ++c) - it++; - } - return sequence; - } - } - - template - inline void - setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) { - typename Sequence::size_type size = self->size(); - Difference ii = 0; - Difference jj = 0; - swig::slice_adjust(i, j, step, size, ii, jj, true); - if (step > 0) { - if (step == 1) { - size_t ssize = jj - ii; - if (ssize <= is.size()) { - // expanding/staying the same size - swig::traits_reserve::reserve(*self, self->size() - ssize + is.size()); - typename Sequence::iterator sb = self->begin(); - typename InputSeq::const_iterator isit = is.begin(); - std::advance(sb,ii); - std::advance(isit, jj - ii); - self->insert(std::copy(is.begin(), isit, sb), isit, is.end()); - } else { - // shrinking - typename Sequence::iterator sb = self->begin(); - typename Sequence::iterator se = self->begin(); - std::advance(sb,ii); - std::advance(se,jj); - self->erase(sb,se); - sb = self->begin(); - std::advance(sb,ii); - self->insert(sb, is.begin(), is.end()); - } - } else { - size_t replacecount = (jj - ii + step - 1) / step; - if (is.size() != replacecount) { - char msg[1024]; - sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); - throw std::invalid_argument(msg); - } - typename Sequence::const_iterator isit = is.begin(); - typename Sequence::iterator it = self->begin(); - std::advance(it,ii); - for (size_t rc=0; rcend(); ++c) - it++; - } - } - } else { - size_t replacecount = (ii - jj - step - 1) / -step; - if (is.size() != replacecount) { - char msg[1024]; - sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); - throw std::invalid_argument(msg); - } - typename Sequence::const_iterator isit = is.begin(); - typename Sequence::reverse_iterator it = self->rbegin(); - std::advance(it,size-ii-1); - for (size_t rc=0; rcrend(); ++c) - it++; - } - } - } - - template - inline void - delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) { - typename Sequence::size_type size = self->size(); - Difference ii = 0; - Difference jj = 0; - swig::slice_adjust(i, j, step, size, ii, jj, true); - if (step > 0) { - typename Sequence::iterator sb = self->begin(); - std::advance(sb,ii); - if (step == 1) { - typename Sequence::iterator se = self->begin(); - std::advance(se,jj); - self->erase(sb,se); - } else { - typename Sequence::iterator it = sb; - size_t delcount = (jj - ii + step - 1) / step; - while (delcount) { - it = self->erase(it); - for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) - it++; - delcount--; - } - } - } else { - typename Sequence::reverse_iterator sb = self->rbegin(); - std::advance(sb,size-ii-1); - typename Sequence::reverse_iterator it = sb; - size_t delcount = (ii - jj - step - 1) / -step; - while (delcount) { - it = typename Sequence::reverse_iterator(self->erase((++it).base())); - for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) - it++; - delcount--; - } - } - } -} - - -#if defined(__SUNPRO_CC) && defined(_RWSTD_VER) -# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL) -# define SWIG_STD_NOITERATOR_TRAITS_STL -# endif -#endif - -#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL) -#include -#else -namespace std { - template - struct iterator_traits { - typedef ptrdiff_t difference_type; - typedef typename Iterator::value_type value_type; - }; - - template - struct iterator_traits<__reverse_bi_iterator > { - typedef Distance difference_type; - typedef T value_type; - }; - - template - struct iterator_traits { - typedef T value_type; - typedef ptrdiff_t difference_type; - }; - - template - inline typename iterator_traits<_InputIterator>::difference_type - distance(_InputIterator __first, _InputIterator __last) - { - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) { - ++__first; ++__n; - } - return __n; - } -} -#endif - - -namespace swig { - template - class SwigPyIterator_T : public SwigPyIterator - { - public: - typedef OutIterator out_iterator; - typedef typename std::iterator_traits::value_type value_type; - typedef SwigPyIterator_T self_type; - - SwigPyIterator_T(out_iterator curr, PyObject *seq) - : SwigPyIterator(seq), current(curr) - { - } - - const out_iterator& get_current() const - { - return current; - } - - - bool equal (const SwigPyIterator &iter) const - { - const self_type *iters = dynamic_cast(&iter); - if (iters) { - return (current == iters->get_current()); - } else { - throw std::invalid_argument("bad iterator type"); - } - } - - ptrdiff_t distance(const SwigPyIterator &iter) const - { - const self_type *iters = dynamic_cast(&iter); - if (iters) { - return std::distance(current, iters->get_current()); - } else { - throw std::invalid_argument("bad iterator type"); - } - } - - protected: - out_iterator current; - }; - - template - struct from_oper - { - typedef const ValueType& argument_type; - typedef PyObject *result_type; - result_type operator()(argument_type v) const - { - return swig::from(v); - } - }; - - template::value_type, - typename FromOper = from_oper > - class SwigPyIteratorOpen_T : public SwigPyIterator_T - { - public: - FromOper from; - typedef OutIterator out_iterator; - typedef ValueType value_type; - typedef SwigPyIterator_T base; - typedef SwigPyIteratorOpen_T self_type; - - SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq) - : SwigPyIterator_T(curr, seq) - { - } - - PyObject *value() const { - return from(static_cast(*(base::current))); - } - - SwigPyIterator *copy() const - { - return new self_type(*this); - } - - SwigPyIterator *incr(size_t n = 1) - { - while (n--) { - ++base::current; - } - return this; - } - - SwigPyIterator *decr(size_t n = 1) - { - while (n--) { - --base::current; - } - return this; - } - }; - - template::value_type, - typename FromOper = from_oper > - class SwigPyIteratorClosed_T : public SwigPyIterator_T - { - public: - FromOper from; - typedef OutIterator out_iterator; - typedef ValueType value_type; - typedef SwigPyIterator_T base; - typedef SwigPyIteratorClosed_T self_type; - - SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) - : SwigPyIterator_T(curr, seq), begin(first), end(last) - { - } - - PyObject *value() const { - if (base::current == end) { - throw stop_iteration(); - } else { - return from(static_cast(*(base::current))); - } - } - - SwigPyIterator *copy() const - { - return new self_type(*this); - } - - SwigPyIterator *incr(size_t n = 1) - { - while (n--) { - if (base::current == end) { - throw stop_iteration(); - } else { - ++base::current; - } - } - return this; - } - - SwigPyIterator *decr(size_t n = 1) - { - while (n--) { - if (base::current == begin) { - throw stop_iteration(); - } else { - --base::current; - } - } - return this; - } - - private: - out_iterator begin; - out_iterator end; - }; - - template - inline SwigPyIterator* - make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) - { - return new SwigPyIteratorClosed_T(current, begin, end, seq); - } - - template - inline SwigPyIterator* - make_output_iterator(const OutIter& current, PyObject *seq = 0) - { - return new SwigPyIteratorOpen_T(current, seq); - } - -} - - -namespace swig -{ - template - struct SwigPySequence_Ref - { - SwigPySequence_Ref(PyObject* seq, Py_ssize_t index) - : _seq(seq), _index(index) - { - } - - operator T () const - { - swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index); - try { - return swig::as(item, true); - } catch (std::exception& e) { - char msg[1024]; - sprintf(msg, "in sequence element %d ", (int)_index); - if (!PyErr_Occurred()) { - ::SWIG_Error(SWIG_TypeError, swig::type_name()); - } - SWIG_Python_AddErrorMsg(msg); - SWIG_Python_AddErrorMsg(e.what()); - throw; - } - } - - SwigPySequence_Ref& operator=(const T& v) - { - PySequence_SetItem(_seq, _index, swig::from(v)); - return *this; - } - - private: - PyObject* _seq; - Py_ssize_t _index; - }; - - template - struct SwigPySequence_ArrowProxy - { - SwigPySequence_ArrowProxy(const T& x): m_value(x) {} - const T* operator->() const { return &m_value; } - operator const T*() const { return &m_value; } - T m_value; - }; - - template - struct SwigPySequence_InputIterator - { - typedef SwigPySequence_InputIterator self; - - typedef std::random_access_iterator_tag iterator_category; - typedef Reference reference; - typedef T value_type; - typedef T* pointer; - typedef Py_ssize_t difference_type; - - SwigPySequence_InputIterator() - { - } - - SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index) - : _seq(seq), _index(index) - { - } - - reference operator*() const - { - return reference(_seq, _index); - } - - SwigPySequence_ArrowProxy - operator->() const { - return SwigPySequence_ArrowProxy(operator*()); - } - - bool operator==(const self& ri) const - { - return (_index == ri._index) && (_seq == ri._seq); - } - - bool operator!=(const self& ri) const - { - return !(operator==(ri)); - } - - self& operator ++ () - { - ++_index; - return *this; - } - - self& operator -- () - { - --_index; - return *this; - } - - self& operator += (difference_type n) - { - _index += n; - return *this; - } - - self operator +(difference_type n) const - { - return self(_seq, _index + n); - } - - self& operator -= (difference_type n) - { - _index -= n; - return *this; - } - - self operator -(difference_type n) const - { - return self(_seq, _index - n); - } - - difference_type operator - (const self& ri) const - { - return _index - ri._index; - } - - bool operator < (const self& ri) const - { - return _index < ri._index; - } - - reference - operator[](difference_type n) const - { - return reference(_seq, _index + n); - } - - private: - PyObject* _seq; - difference_type _index; - }; - - // STL container wrapper around a Python sequence - template - struct SwigPySequence_Cont - { - typedef SwigPySequence_Ref reference; - typedef const SwigPySequence_Ref const_reference; - typedef T value_type; - typedef T* pointer; - typedef Py_ssize_t difference_type; - typedef size_t size_type; - typedef const pointer const_pointer; - typedef SwigPySequence_InputIterator iterator; - typedef SwigPySequence_InputIterator const_iterator; - - SwigPySequence_Cont(PyObject* seq) : _seq(0) - { - if (!PySequence_Check(seq)) { - throw std::invalid_argument("a sequence is expected"); - } - _seq = seq; - Py_INCREF(_seq); - } - - ~SwigPySequence_Cont() - { - Py_XDECREF(_seq); - } - - size_type size() const - { - return static_cast(PySequence_Size(_seq)); - } - - bool empty() const - { - return size() == 0; - } - - iterator begin() - { - return iterator(_seq, 0); - } - - const_iterator begin() const - { - return const_iterator(_seq, 0); - } - - iterator end() - { - return iterator(_seq, size()); - } - - const_iterator end() const - { - return const_iterator(_seq, size()); - } - - reference operator[](difference_type n) - { - return reference(_seq, n); - } - - const_reference operator[](difference_type n) const - { - return const_reference(_seq, n); - } - - bool check(bool set_err = true) const - { - Py_ssize_t s = size(); - for (Py_ssize_t i = 0; i < s; ++i) { - swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i); - if (!swig::check(item)) { - if (set_err) { - char msg[1024]; - sprintf(msg, "in sequence element %d", (int)i); - SWIG_Error(SWIG_RuntimeError, msg); - } - return false; - } - } - return true; - } - - private: - PyObject* _seq; - }; - -} - - -SWIGINTERN int -SWIG_AsVal_int (PyObject * obj, int *val) -{ - long v; - int res = SWIG_AsVal_long (obj, &v); - if (SWIG_IsOK(res)) { - if ((v < INT_MIN || v > INT_MAX)) { - return SWIG_OverflowError; - } else { - if (val) *val = static_cast< int >(v); - } - } - return res; -} - - -SWIGINTERNINLINE PyObject* - SWIG_From_int (int value) -{ - return PyInt_FromLong((long) value); -} - - -namespace swig { - template <> struct traits< int > { - typedef value_category category; - static const char* type_name() { return"int"; } - }; - template <> struct traits_asval< int > { - typedef int value_type; - static int asval(PyObject *obj, value_type *val) { - return SWIG_AsVal_int (obj, val); - } - }; - template <> struct traits_from< int > { - typedef int value_type; - static PyObject *from(const value_type& val) { - return SWIG_From_int (val); - } - }; -} - - -namespace swig { - template - inline void - assign(const SwigPySeq& swigpyseq, Seq* seq) { - // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented - typedef typename SwigPySeq::value_type value_type; - typename SwigPySeq::const_iterator it = swigpyseq.begin(); - for (;it != swigpyseq.end(); ++it) { - seq->insert(seq->end(),(value_type)(*it)); - } - } - - template - struct traits_asptr_stdseq { - typedef Seq sequence; - typedef T value_type; - - static int asptr(PyObject *obj, sequence **seq) { - if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) { - sequence *p; - swig_type_info *descriptor = swig::type_info(); - if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) { - if (seq) *seq = p; - return SWIG_OLDOBJ; - } - } else if (PySequence_Check(obj)) { - try { - SwigPySequence_Cont swigpyseq(obj); - if (seq) { - sequence *pseq = new sequence(); - assign(swigpyseq, pseq); - *seq = pseq; - return SWIG_NEWOBJ; - } else { - return swigpyseq.check() ? SWIG_OK : SWIG_ERROR; - } - } catch (std::exception& e) { - if (seq) { - if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, e.what()); - } - } - return SWIG_ERROR; - } - } - return SWIG_ERROR; - } - }; - - template - struct traits_from_stdseq { - typedef Seq sequence; - typedef T value_type; - typedef typename Seq::size_type size_type; - typedef typename sequence::const_iterator const_iterator; - - static PyObject *from(const sequence& seq) { -#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS - swig_type_info *desc = swig::type_info(); - if (desc && desc->clientdata) { - return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); - } -#endif - size_type size = seq.size(); - if (size <= (size_type)INT_MAX) { - PyObject *obj = PyTuple_New((Py_ssize_t)size); - Py_ssize_t i = 0; - for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) { - PyTuple_SetItem(obj,i,swig::from(*it)); - } - return obj; - } else { - PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python"); - return NULL; - } - } - }; -} - - - namespace swig { - template - struct traits_reserve > { - static void reserve(std::vector &seq, typename std::vector::size_type n) { - seq.reserve(n); - } - }; - - template - struct traits_asptr > { - static int asptr(PyObject *obj, std::vector **vec) { - return traits_asptr_stdseq >::asptr(obj, vec); - } - }; - - template - struct traits_from > { - static PyObject *from(const std::vector& vec) { - return traits_from_stdseq >::from(vec); - } - }; - } - - - namespace swig { - template <> struct traits > > { - typedef pointer_category category; - static const char* type_name() { - return "std::vector<" "int" "," "std::allocator< int >" " >"; - } - }; - } - -SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){ - return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); - } -SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){ - return !(self->empty()); - } -SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){ - return !(self->empty()); - } -SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){ - return self->size(); - } - -SWIGINTERNINLINE PyObject* -SWIG_From_unsigned_SS_long (unsigned long value) -{ - return (value > LONG_MAX) ? - PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); -} - - -#ifdef SWIG_LONG_LONG_AVAILABLE -SWIGINTERNINLINE PyObject* -SWIG_From_unsigned_SS_long_SS_long (unsigned long long value) -{ - return (value > LONG_MAX) ? - PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value)); -} -#endif - - -SWIGINTERNINLINE PyObject * -SWIG_From_size_t (size_t value) -{ -#ifdef SWIG_LONG_LONG_AVAILABLE - if (sizeof(size_t) <= sizeof(unsigned long)) { -#endif - return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); -#ifdef SWIG_LONG_LONG_AVAILABLE - } else { - /* assume sizeof(size_t) <= sizeof(unsigned long long) */ - return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value)); - } -#endif -} - -SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ - return swig::getslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ - swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >()); - } -SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){ - swig::setslice(self, i, j, 1, v); - } -SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ - swig::delslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){ - swig::erase(self, swig::getpos(self, i)); - } -SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return NULL; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< int,std::allocator< int > >::difference_type id = i; - std::vector< int,std::allocator< int > >::difference_type jd = j; - return swig::getslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< int,std::allocator< int > >::difference_type id = i; - std::vector< int,std::allocator< int > >::difference_type jd = j; - swig::setslice(self, id, jd, step, v); - } -SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< int,std::allocator< int > >::difference_type id = i; - std::vector< int,std::allocator< int > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< int,std::allocator< int > >::difference_type id = i; - std::vector< int,std::allocator< int > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){ - return *(swig::cgetpos(self, i)); - } -SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){ - *(swig::getpos(self,i)) = x; - } -SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){ - if (self->size() == 0) - throw std::out_of_range("pop from empty container"); - std::vector< int,std::allocator< int > >::value_type x = self->back(); - self->pop_back(); - return x; - } -SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){ - self->push_back(x); - } -SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); } -SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); } -SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); } -SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); } - -#define SWIG_FILE_WITH_INIT - -#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ - (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ - (PY_MAJOR_VERSION > 3)) -#define CAPSULES_SUPPORTED -#endif - -#ifndef NPY_ARRAY_C_CONTIGUOUS - #define NPY_ARRAY_C_CONTIGUOUS NPY_C_CONTIGUOUS - #define PyArray_SetBaseObject(arr, x) (PyArray_BASE(arr) = (x)) -#endif - - -#ifndef SWIG_FILE_WITH_INIT -# define NO_IMPORT_ARRAY -#endif -#include "stdio.h" -#include - - -/* - #define SWIG_FILE_WITH_INIT - #include - #include - #include - #include - #include - //#include - #include - //#include - #include - #include - #include - #include - #include - #include - #include - #include -*/ - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - #include - using namespace aruco; - - -/* Support older NumPy data type names -*/ -#if NDARRAY_VERSION < 0x01000000 -#define NPY_BOOL PyArray_BOOL -#define NPY_BYTE PyArray_BYTE -#define NPY_UBYTE PyArray_UBYTE -#define NPY_SHORT PyArray_SHORT -#define NPY_USHORT PyArray_USHORT -#define NPY_INT PyArray_INT -#define NPY_UINT PyArray_UINT -#define NPY_LONG PyArray_LONG -#define NPY_ULONG PyArray_ULONG -#define NPY_LONGLONG PyArray_LONGLONG -#define NPY_ULONGLONG PyArray_ULONGLONG -#define NPY_FLOAT PyArray_FLOAT -#define NPY_DOUBLE PyArray_DOUBLE -#define NPY_LONGDOUBLE PyArray_LONGDOUBLE -#define NPY_CFLOAT PyArray_CFLOAT -#define NPY_CDOUBLE PyArray_CDOUBLE -#define NPY_CLONGDOUBLE PyArray_CLONGDOUBLE -#define NPY_OBJECT PyArray_OBJECT -#define NPY_STRING PyArray_STRING -#define NPY_UNICODE PyArray_UNICODE -#define NPY_VOID PyArray_VOID -#define NPY_NTYPES PyArray_NTYPES -#define NPY_NOTYPE PyArray_NOTYPE -#define NPY_CHAR PyArray_CHAR -#define NPY_USERDEF PyArray_USERDEF -#define npy_intp intp - -#define NPY_MAX_BYTE MAX_BYTE -#define NPY_MIN_BYTE MIN_BYTE -#define NPY_MAX_UBYTE MAX_UBYTE -#define NPY_MAX_SHORT MAX_SHORT -#define NPY_MIN_SHORT MIN_SHORT -#define NPY_MAX_USHORT MAX_USHORT -#define NPY_MAX_INT MAX_INT -#define NPY_MIN_INT MIN_INT -#define NPY_MAX_UINT MAX_UINT -#define NPY_MAX_LONG MAX_LONG -#define NPY_MIN_LONG MIN_LONG -#define NPY_MAX_ULONG MAX_ULONG -#define NPY_MAX_LONGLONG MAX_LONGLONG -#define NPY_MIN_LONGLONG MIN_LONGLONG -#define NPY_MAX_ULONGLONG MAX_ULONGLONG -#define NPY_MAX_INTP MAX_INTP -#define NPY_MIN_INTP MIN_INTP - -#define NPY_FARRAY FARRAY -#define NPY_F_CONTIGUOUS F_CONTIGUOUS -#endif - - -/* Macros to extract array attributes. - */ -#define is_array(a) ((a) && PyArray_Check((PyArrayObject *)a)) -#define array_type(a) (int)(PyArray_TYPE(a)) -#define array_numdims(a) (((PyArrayObject *)a)->nd) -#define array_dimensions(a) (((PyArrayObject *)a)->dimensions) -#define array_size(a,i) (((PyArrayObject *)a)->dimensions[i]) -#define array_data(a) (((PyArrayObject *)a)->data) -#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a)) -#define array_is_native(a) (PyArray_ISNOTSWAPPED(a)) -#define array_is_fortran(a) (PyArray_ISFORTRAN(a)) - - - /* Given a PyObject, return a string describing its type. - */ - const char* pytype_string(PyObject* py_obj) { - if (py_obj == NULL ) return "C NULL value"; - if (py_obj == Py_None ) return "Python None" ; - if (PyCallable_Check(py_obj)) return "callable" ; - if (PyString_Check( py_obj)) return "string" ; - if (PyInt_Check( py_obj)) return "int" ; - if (PyFloat_Check( py_obj)) return "float" ; - if (PyDict_Check( py_obj)) return "dict" ; - if (PyList_Check( py_obj)) return "list" ; - if (PyTuple_Check( py_obj)) return "tuple" ; - if (PyModule_Check( py_obj)) return "module" ; -#if PY_MAJOR_VERSION < 3 - if (PyFile_Check( py_obj)) return "file" ; - if (PyInstance_Check(py_obj)) return "instance" ; -#endif - - return "unkown type"; - } - - /* Given a NumPy typecode, return a string describing the type. - */ - const char* typecode_string(int typecode) { - static const char* type_names[25] = {"bool", "byte", "unsigned byte", - "short", "unsigned short", "int", - "unsigned int", "long", "unsigned long", - "long long", "unsigned long long", - "float", "double", "long double", - "complex float", "complex double", - "complex long double", "object", - "string", "unicode", "void", "ntypes", - "notype", "char", "unknown"}; - return typecode < 24 ? type_names[typecode] : type_names[24]; - } - - /* Make sure input has correct numpy type. Allow character and byte - * to match. Also allow int and long to match. This is deprecated. - * You should use PyArray_EquivTypenums() instead. - */ - int type_match(int actual_type, int desired_type) { - return PyArray_EquivTypenums(actual_type, desired_type); - } - - - /* Given a PyObject pointer, cast it to a PyArrayObject pointer if - * legal. If not, set the python error string appropriately and - * return NULL. - */ - PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode) - { - PyArrayObject* ary = NULL; - if (is_array(input) && (typecode == NPY_NOTYPE || - PyArray_EquivTypenums(array_type(input), typecode))) - { - ary = (PyArrayObject*) input; - } - else if is_array(input) - { - const char* desired_type = typecode_string(typecode); - const char* actual_type = typecode_string(array_type(input)); - PyErr_Format(PyExc_TypeError, - "Array of type '%s' required. Array of type '%s' given", - desired_type, actual_type); - ary = NULL; - } - else - { - const char * desired_type = typecode_string(typecode); - const char * actual_type = pytype_string(input); - PyErr_Format(PyExc_TypeError, - "Array of type '%s' required. A '%s' was given", - desired_type, actual_type); - ary = NULL; - } - return ary; - } - - /* Convert the given PyObject to a NumPy array with the given - * typecode. On success, return a valid PyArrayObject* with the - * correct type. On failure, the python error string will be set and - * the routine returns NULL. - */ - PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode, - int* is_new_object) - { - PyArrayObject* ary = NULL; - PyObject* py_obj; - if (is_array(input) && (typecode == NPY_NOTYPE || - PyArray_EquivTypenums(array_type(input),typecode))) - { - ary = (PyArrayObject*) input; - *is_new_object = 0; - } - else - { - py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_DEFAULT); - /* If NULL, PyArray_FromObject will have set python error value.*/ - ary = (PyArrayObject*) py_obj; - *is_new_object = 1; - } - return ary; - } - - /* Given a PyArrayObject, check to see if it is contiguous. If so, - * return the input pointer and flag it as not a new object. If it is - * not contiguous, create a new PyArrayObject using the original data, - * flag it as a new object and return the pointer. - */ - PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object, - int min_dims, int max_dims) - { - PyArrayObject* result; - if (array_is_contiguous(ary)) - { - result = ary; - *is_new_object = 0; - } - else - { - result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary, - array_type(ary), - min_dims, - max_dims); - *is_new_object = 1; - } - return result; - } - - /* Given a PyArrayObject, check to see if it is Fortran-contiguous. - * If so, return the input pointer, but do not flag it as not a new - * object. If it is not Fortran-contiguous, create a new - * PyArrayObject using the original data, flag it as a new object - * and return the pointer. - */ - PyArrayObject* make_fortran(PyArrayObject* ary, int* is_new_object, - int min_dims, int max_dims) - { - PyArrayObject* result; - if (array_is_fortran(ary)) - { - result = ary; - *is_new_object = 0; - } - else - { - Py_INCREF(ary->descr); - result = (PyArrayObject*) PyArray_FromArray(ary, ary->descr, NPY_FORTRAN); - *is_new_object = 1; - } - return result; - } - - /* Convert a given PyObject to a contiguous PyArrayObject of the - * specified type. If the input object is not a contiguous - * PyArrayObject, a new one will be created and the new object flag - * will be set. - */ - PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input, - int typecode, - int* is_new_object) - { - int is_new1 = 0; - int is_new2 = 0; - PyArrayObject* ary2; - PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, - &is_new1); - if (ary1) - { - ary2 = make_contiguous(ary1, &is_new2, 0, 0); - if ( is_new1 && is_new2) - { - Py_DECREF(ary1); - } - ary1 = ary2; - } - *is_new_object = is_new1 || is_new2; - return ary1; - } - - /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the - * specified type. If the input object is not a Fortran-ordered - * PyArrayObject, a new one will be created and the new object flag - * will be set. - */ - PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input, - int typecode, - int* is_new_object) - { - int is_new1 = 0; - int is_new2 = 0; - PyArrayObject* ary2; - PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, - &is_new1); - if (ary1) - { - ary2 = make_fortran(ary1, &is_new2, 0, 0); - if (is_new1 && is_new2) - { - Py_DECREF(ary1); - } - ary1 = ary2; - } - *is_new_object = is_new1 || is_new2; - return ary1; - } - - - - /* Test whether a python object is contiguous. If array is - * contiguous, return 1. Otherwise, set the python error string and - * return 0. - */ - int require_contiguous(PyArrayObject* ary) - { - int contiguous = 1; - if (!array_is_contiguous(ary)) - { - PyErr_SetString(PyExc_TypeError, - "Array must be contiguous. A non-contiguous array was given"); - contiguous = 0; - } - return contiguous; - } - - /* Require that a numpy array is not byte-swapped. If the array is - * not byte-swapped, return 1. Otherwise, set the python error string - * and return 0. - */ - int require_native(PyArrayObject* ary) - { - int native = 1; - if (!array_is_native(ary)) - { - PyErr_SetString(PyExc_TypeError, - "Array must have native byteorder. " - "A byte-swapped array was given"); - native = 0; - } - return native; - } - - /* Require the given PyArrayObject to have a specified number of - * dimensions. If the array has the specified number of dimensions, - * return 1. Otherwise, set the python error string and return 0. - */ - int require_dimensions(PyArrayObject* ary, int exact_dimensions) - { - int success = 1; - if (array_numdims(ary) != exact_dimensions) - { - PyErr_Format(PyExc_TypeError, - "Array must have %d dimensions. Given array has %d dimensions", - exact_dimensions, array_numdims(ary)); - success = 0; - } - return success; - } - - /* Require the given PyArrayObject to have one of a list of specified - * number of dimensions. If the array has one of the specified number - * of dimensions, return 1. Otherwise, set the python error string - * and return 0. - */ - int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n) - { - int success = 0; - int i; - char dims_str[255] = ""; - char s[255]; - for (i = 0; i < n && !success; i++) - { - if (array_numdims(ary) == exact_dimensions[i]) - { - success = 1; - } - } - if (!success) - { - for (i = 0; i < n-1; i++) - { - sprintf(s, "%d, ", exact_dimensions[i]); - strcat(dims_str,s); - } - sprintf(s, " or %d", exact_dimensions[n-1]); - strcat(dims_str,s); - PyErr_Format(PyExc_TypeError, - "Array must have %s dimensions. Given array has %d dimensions", - dims_str, array_numdims(ary)); - } - return success; - } - - /* Require the given PyArrayObject to have a specified shape. If the - * array has the specified shape, return 1. Otherwise, set the python - * error string and return 0. - */ - int require_size(PyArrayObject* ary, npy_intp* size, int n) - { - int i; - int success = 1; - int len; - char desired_dims[255] = "["; - char s[255]; - char actual_dims[255] = "["; - for(i=0; i < n;i++) - { - if (size[i] != -1 && size[i] != array_size(ary,i)) - { - success = 0; - } - } - if (!success) - { - for (i = 0; i < n; i++) - { - if (size[i] == -1) - { - sprintf(s, "*,"); - } - else - { - sprintf(s, "%ld,", (long int)size[i]); - } - strcat(desired_dims,s); - } - len = strlen(desired_dims); - desired_dims[len-1] = ']'; - for (i = 0; i < n; i++) - { - sprintf(s, "%ld,", (long int)array_size(ary,i)); - strcat(actual_dims,s); - } - len = strlen(actual_dims); - actual_dims[len-1] = ']'; - PyErr_Format(PyExc_TypeError, - "Array must have shape of %s. Given array has shape of %s", - desired_dims, actual_dims); - } - return success; - } - - /* Require the given PyArrayObject to to be FORTRAN ordered. If the - * the PyArrayObject is already FORTRAN ordered, do nothing. Else, - * set the FORTRAN ordering flag and recompute the strides. - */ - int require_fortran(PyArrayObject* ary) - { - int success = 1; - int nd = array_numdims(ary); - int i; - if (array_is_fortran(ary)) return success; - /* Set the FORTRAN ordered flag */ - ary->flags = NPY_FARRAY; - /* Recompute the strides */ - ary->strides[0] = ary->strides[nd-1]; - for (i=1; i < nd; ++i) - ary->strides[i] = ary->strides[i-1] * array_size(ary,i-1); - return success; - } - - - - // convert NumPy type to OpenCV type - int numpy_type_to_mat_type(PyArrayObject *array, int channels) - { - switch (array_type(array)) { - case NPY_BYTE: return CV_MAKETYPE(CV_8S, channels); - case NPY_UBYTE: return CV_MAKETYPE(CV_8U, channels); - case NPY_SHORT: return CV_MAKETYPE(CV_16S, channels); - case NPY_USHORT: return CV_MAKETYPE(CV_16U, channels); - case NPY_INT: return CV_MAKETYPE(CV_32S, channels); - //case NPY_UINT: // does not exist - //case NPY_LONG: // does not exist - //case NPY_ULONG: // does not exist - case NPY_FLOAT: return CV_MAKETYPE(CV_32F, channels); - case NPY_DOUBLE: return CV_MAKETYPE(CV_64F, channels); - default: - PyErr_Format(PyExc_TypeError, - "Unsupported datatype: %s.", - typecode_string(array_type(array))); - } - return -1; - } - - // convert OpenCV type to NumPy type - int mat_type_to_numpy_type(int type) - { - // convert numpy type to CV type - switch (CV_MAT_DEPTH(type)) { - case CV_8S: return NPY_BYTE; - case CV_8U: return NPY_UBYTE; - case CV_16S: return NPY_SHORT; - case CV_16U: return NPY_USHORT; - case CV_32S: return NPY_INT; - //case NPY_UINT: // does not exist - //case NPY_LONG: // does not exist - //case NPY_ULONG: // does not exist - case CV_32F: return NPY_FLOAT; - case CV_64F: return NPY_DOUBLE; - default: - PyErr_Format(PyExc_TypeError, - "Unsupported OpenCV datatype: %d (depth: %d).", - type, CV_MAT_DEPTH(type)); - } - return -1; - } - - void delete_mat(void *ptr) - { - // printf("deleting underlying mat at %p\n", ptr); - cv::Mat *m = static_cast< cv::Mat* >(ptr); - assert (m != NULL); - delete m; - } - -#ifdef CAPSULES_SUPPORTED - void delete_mat_capsule(PyObject *obj) - { - // printf("deleting underlying mat at %p\n", ptr); - cv::Mat *m = static_cast< cv::Mat* >(PyCapsule_GetPointer(obj, NULL)); - assert (m != NULL); - delete m; - } -#endif - - - - cv::Scalar* array_to_scalar(PyObject* input) - { - PyArrayObject* array = obj_to_array_no_conversion(input, NPY_NOTYPE); - if (array == NULL) { - // error message is set by obj_to_array_no_conversion - return NULL; - } - - // creates 4-element integer array ToDo: diff. convert data types - size_t size = array_size(array, 0); - size_t step = array->strides[0]; - int data[4] = {0, 0, 0, 0}; - for(size_t i=0, j=0; istrides[0]; - int data[4] = {0, 0, 0, 0}; - for(size_t i=0, j=0; i 4) { - PyErr_Format(PyExc_TypeError, - "Array can have a maximum of 4 channels. Input as %d.", channels); - return NULL; - } - } - else { - PyErr_Format(PyExc_TypeError, - "Array must be 2- or 3-dimensional. Input is %d-dimensional.", ndims); - return NULL; - } - - // convert NumPy type to OpenCV type - if ((type = numpy_type_to_mat_type(array, channels)) == -1) - return NULL; - - // check that array is in C order - for (int i = 0; i < ndims-1; ++i) { - if (PyArray_STRIDE(array, i) < PyArray_STRIDE(array, i+1)) { - PyErr_Format(PyExc_TypeError, - "Array is not in C order: stride of dim %d: %ld < stride of dim %d: %ld", - i, PyArray_STRIDE(array, i), i+1, PyArray_STRIDE(array, i+1)); - return NULL; - } - } - - // use stride of first dimension as stepsize - // and check strides of other dimensions - int step = ((PyArrayObject *)array)->strides[0]; - if (PyArray_STRIDE(array, 1) != channels * PyArray_ITEMSIZE(array)) { - PyErr_Format(PyExc_TypeError, - "Array cannot have strides in other than 1st dimension (rows). Dim 2: %ld vs %d", - PyArray_STRIDE(array, 1), channels * PyArray_ITEMSIZE(array)); - return NULL; - } - - // create new view onto the data - return new cv::Mat(array_size(array, 0), array_size(array, 1), type, array_data(array), step); - } - - PyObject* mat_to_array(const cv::Mat& mat) - { - // handle empty mat - if (mat.empty()) { - npy_intp dims[1] = { 0 }; - int type = mat_type_to_numpy_type(mat.type()); - PyObject* array = PyArray_EMPTY(1, dims, type, 0); - return array; - } - - npy_intp dims[3] = { mat.rows, mat.cols, mat.channels() }; - npy_intp strides[3] = { (npy_intp)mat.step, (npy_intp)mat.elemSize(), (npy_intp)mat.elemSize1()}; - int ndims = (mat.channels() > 1) ? 3 : 2; - int type = mat_type_to_numpy_type(mat.type()); - int flags = NPY_WRITEABLE; - if (mat.isContinuous()) - flags |= NPY_C_CONTIGUOUS; - PyObject* array = PyArray_New(&PyArray_Type, ndims, dims, type, - strides, mat.data, 0, flags, NULL); - return array; - } - - PyObject* point2f_to_array(cv::Point2f* point) - { - npy_intp dims = 2; - npy_intp strides[1] = { 1 }; - int flags = NPY_WRITEABLE; - float *data = new float[2]; - data[0] = point->x; - data[1] = point->y; - PyObject* array = PyArray_SimpleNewFromData(1, &dims, NPY_FLOAT, data); - return array; - } - - PyObject* point3f_to_array(cv::Point3f* point) - { - npy_intp dims = 3; - npy_intp strides[1] = { 1 }; - int flags = NPY_WRITEABLE; - float *data = new float[3]; - data[0] = point->x; - data[1] = point->y; - data[2] = point->z; - PyObject* array = PyArray_SimpleNewFromData(1, &dims, NPY_FLOAT, data); - return array; - } - - -SWIGINTERN swig_type_info* -SWIG_pchar_descriptor(void) -{ - static int init = 0; - static swig_type_info* info = 0; - if (!init) { - info = SWIG_TypeQuery("_p_char"); - init = 1; - } - return info; -} - - -SWIGINTERN int -SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -{ -#if PY_VERSION_HEX>=0x03000000 -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - if (PyBytes_Check(obj)) -#else - if (PyUnicode_Check(obj)) -#endif -#else - if (PyString_Check(obj)) -#endif - { - char *cstr; Py_ssize_t len; -#if PY_VERSION_HEX>=0x03000000 -#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - if (!alloc && cptr) { - /* We can't allow converting without allocation, since the internal - representation of string in Python 3 is UCS-2/UCS-4 but we require - a UTF-8 representation. - TODO(bhy) More detailed explanation */ - return SWIG_RuntimeError; - } - obj = PyUnicode_AsUTF8String(obj); - if(alloc) *alloc = SWIG_NEWOBJ; -#endif - PyBytes_AsStringAndSize(obj, &cstr, &len); -#else - PyString_AsStringAndSize(obj, &cstr, &len); -#endif - if (cptr) { - if (alloc) { - /* - In python the user should not be able to modify the inner - string representation. To warranty that, if you define - SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string - buffer is always returned. - - The default behavior is just to return the pointer value, - so, be careful. - */ -#if defined(SWIG_PYTHON_SAFE_CSTRINGS) - if (*alloc != SWIG_OLDOBJ) -#else - if (*alloc == SWIG_NEWOBJ) -#endif - { - *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); - *alloc = SWIG_NEWOBJ; - } else { - *cptr = cstr; - *alloc = SWIG_OLDOBJ; - } - } else { -#if PY_VERSION_HEX>=0x03000000 -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - *cptr = PyBytes_AsString(obj); -#else - assert(0); /* Should never reach here with Unicode strings in Python 3 */ -#endif -#else - *cptr = SWIG_Python_str_AsChar(obj); -#endif - } - } - if (psize) *psize = len + 1; -#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - Py_XDECREF(obj); -#endif - return SWIG_OK; - } else { -#if defined(SWIG_PYTHON_2_UNICODE) -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) -#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once" -#endif -#if PY_VERSION_HEX<0x03000000 - if (PyUnicode_Check(obj)) { - char *cstr; Py_ssize_t len; - if (!alloc && cptr) { - return SWIG_RuntimeError; - } - obj = PyUnicode_AsUTF8String(obj); - if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) { - if (cptr) { - if (alloc) *alloc = SWIG_NEWOBJ; - *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); - } - if (psize) *psize = len + 1; - - Py_XDECREF(obj); - return SWIG_OK; - } else { - Py_XDECREF(obj); - } - } -#endif -#endif - - swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); - if (pchar_descriptor) { - void* vptr = 0; - if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { - if (cptr) *cptr = (char *) vptr; - if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; - if (alloc) *alloc = SWIG_OLDOBJ; - return SWIG_OK; - } - } - } - return SWIG_TypeError; -} - - -SWIGINTERN int -SWIG_AsPtr_std_string (PyObject * obj, std::string **val) -{ - char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ; - if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) { - if (buf) { - if (val) *val = new std::string(buf, size - 1); - if (alloc == SWIG_NEWOBJ) delete[] buf; - return SWIG_NEWOBJ; - } else { - if (val) *val = 0; - return SWIG_OLDOBJ; - } - } else { - static int init = 0; - static swig_type_info* descriptor = 0; - if (!init) { - descriptor = SWIG_TypeQuery("std::string" " *"); - init = 1; - } - if (descriptor) { - std::string *vptr; - int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0); - if (SWIG_IsOK(res) && val) *val = vptr; - return res; - } - } - return SWIG_ERROR; -} - - -SWIGINTERN int -SWIG_AsVal_bool (PyObject *obj, bool *val) -{ - int r; - if (!PyBool_Check(obj)) - return SWIG_ERROR; - r = PyObject_IsTrue(obj); - if (r == -1) - return SWIG_ERROR; - if (val) *val = r ? true : false; - return SWIG_OK; -} - - -/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */ -#ifndef SWIG_isfinite -/* isfinite() is a macro for C99 */ -# if defined(isfinite) -# define SWIG_isfinite(X) (isfinite(X)) -# elif defined __cplusplus && __cplusplus >= 201103L -/* Use a template so that this works whether isfinite() is std::isfinite() or - * in the global namespace. The reality seems to vary between compiler - * versions. - * - * Make sure namespace std exists to avoid compiler warnings. - * - * extern "C++" is required as this fragment can end up inside an extern "C" { } block - */ -namespace std { } -extern "C++" template -inline int SWIG_isfinite_func(T x) { - using namespace std; - return isfinite(x); -} -# define SWIG_isfinite(X) (SWIG_isfinite_func(X)) -# elif defined(_MSC_VER) -# define SWIG_isfinite(X) (_finite(X)) -# elif defined(__sun) && defined(__SVR4) -# include -# define SWIG_isfinite(X) (finite(X)) -# endif -#endif - - -/* Accept infinite as a valid float value unless we are unable to check if a value is finite */ -#ifdef SWIG_isfinite -# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X)) -#else -# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX)) -#endif - - -SWIGINTERN int -SWIG_AsVal_float (PyObject * obj, float *val) -{ - double v; - int res = SWIG_AsVal_double (obj, &v); - if (SWIG_IsOK(res)) { - if (SWIG_Float_Overflow_Check(v)) { - return SWIG_OverflowError; - } else { - if (val) *val = static_cast< float >(v); - } - } - return res; -} - - -SWIGINTERNINLINE PyObject * -SWIG_FromCharPtrAndSize(const char* carray, size_t size) -{ - if (carray) { - if (size > INT_MAX) { - swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); - return pchar_descriptor ? - SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); - } else { -#if PY_VERSION_HEX >= 0x03000000 -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#else -#if PY_VERSION_HEX >= 0x03010000 - return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); -#else - return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#endif -#endif -#else - return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#endif - } - } else { - return SWIG_Py_Void(); - } -} - - -SWIGINTERNINLINE PyObject * -SWIG_From_std_string (const std::string& s) -{ - return SWIG_FromCharPtrAndSize(s.data(), s.size()); -} - - - namespace swig { - template <> struct traits< cv::Point2f > { - typedef pointer_category category; - static const char* type_name() { return"cv::Point2f"; } - }; - } - - - namespace swig { - template <> struct traits > > { - typedef pointer_category category; - static const char* type_name() { - return "std::vector<" "cv::Point2f" "," "std::allocator< cv::Point2f >" " >"; - } - }; - } - -SWIGINTERN swig::SwigPyIterator *std_vector_Sl_cv_Point2f_Sg__iterator(std::vector< cv::Point2f > *self,PyObject **PYTHON_SELF){ - return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); - } -SWIGINTERN bool std_vector_Sl_cv_Point2f_Sg____nonzero__(std::vector< cv::Point2f > const *self){ - return !(self->empty()); - } -SWIGINTERN bool std_vector_Sl_cv_Point2f_Sg____bool__(std::vector< cv::Point2f > const *self){ - return !(self->empty()); - } -SWIGINTERN std::vector< cv::Point2f >::size_type std_vector_Sl_cv_Point2f_Sg____len__(std::vector< cv::Point2f > const *self){ - return self->size(); - } -SWIGINTERN std::vector< cv::Point2f,std::allocator< cv::Point2f > > *std_vector_Sl_cv_Point2f_Sg____getslice__(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j){ - return swig::getslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j){ - swig::setslice(self, i, j, 1, std::vector< cv::Point2f,std::allocator< cv::Point2f > >()); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_1(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &v){ - swig::setslice(self, i, j, 1, v); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____delslice__(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::difference_type j){ - swig::delslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i){ - swig::erase(self, swig::getpos(self, i)); - } -SWIGINTERN std::vector< cv::Point2f,std::allocator< cv::Point2f > > *std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_0(std::vector< cv::Point2f > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return NULL; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; - return swig::getslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_0(std::vector< cv::Point2f > *self,PySliceObject *slice,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &v){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; - swig::setslice(self, id, jd, step, v); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_1(std::vector< cv::Point2f > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_1(std::vector< cv::Point2f > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type id = i; - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN std::vector< cv::Point2f >::value_type const &std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_1(std::vector< cv::Point2f > const *self,std::vector< cv::Point2f >::difference_type i){ - return *(swig::cgetpos(self, i)); - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_2(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::difference_type i,std::vector< cv::Point2f >::value_type const &x){ - *(swig::getpos(self,i)) = x; - } -SWIGINTERN std::vector< cv::Point2f >::value_type std_vector_Sl_cv_Point2f_Sg__pop(std::vector< cv::Point2f > *self){ - if (self->size() == 0) - throw std::out_of_range("pop from empty container"); - std::vector< cv::Point2f,std::allocator< cv::Point2f > >::value_type x = self->back(); - self->pop_back(); - return x; - } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg__append(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::value_type const &x){ - self->push_back(x); - } -SWIGINTERN std::vector< cv::Point2f >::iterator std_vector_Sl_cv_Point2f_Sg__erase__SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator pos){ return self->erase(pos); } -SWIGINTERN std::vector< cv::Point2f >::iterator std_vector_Sl_cv_Point2f_Sg__erase__SWIG_1(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator first,std::vector< cv::Point2f >::iterator last){ return self->erase(first, last); } -SWIGINTERN std::vector< cv::Point2f >::iterator std_vector_Sl_cv_Point2f_Sg__insert__SWIG_0(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator pos,std::vector< cv::Point2f >::value_type const &x){ return self->insert(pos, x); } -SWIGINTERN void std_vector_Sl_cv_Point2f_Sg__insert__SWIG_1(std::vector< cv::Point2f > *self,std::vector< cv::Point2f >::iterator pos,std::vector< cv::Point2f >::size_type n,std::vector< cv::Point2f >::value_type const &x){ self->insert(pos, n, x); } - - namespace swig { - template <> struct traits< aruco::Marker > { - typedef pointer_category category; - static const char* type_name() { return"aruco::Marker"; } - }; - } - - - namespace swig { - template <> struct traits > > { - typedef pointer_category category; - static const char* type_name() { - return "std::vector<" "aruco::Marker" "," "std::allocator< aruco::Marker >" " >"; - } - }; - } - -SWIGINTERN swig::SwigPyIterator *std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__iterator(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PyObject **PYTHON_SELF){ - return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); - } -SWIGINTERN bool std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____nonzero__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self){ - return !(self->empty()); - } -SWIGINTERN bool std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____bool__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self){ - return !(self->empty()); - } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____len__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self){ - return self->size(); - } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > > *std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j){ - return swig::getslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j){ - swig::setslice(self, i, j, 1, std::vector< aruco::Marker,std::allocator< aruco::Marker > >()); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &v){ - swig::setslice(self, i, j, 1, v); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type j){ - swig::delslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i){ - swig::erase(self, swig::getpos(self, i)); - } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > > *std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return NULL; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; - return swig::getslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &v){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; - swig::setslice(self, id, jd, step, v); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type id = i; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i){ - return *(swig::cgetpos(self, i)); - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_2(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type i,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ - *(swig::getpos(self,i)) = x; - } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__pop(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self){ - if (self->size() == 0) - throw std::out_of_range("pop from empty container"); - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type x = self->back(); - self->pop_back(); - return x; - } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__append(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ - self->push_back(x); - } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator pos){ return self->erase(pos); } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator first,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator last){ return self->erase(first, last); } -SWIGINTERN std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_0(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator pos,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ return self->insert(pos, x); } -SWIGINTERN void std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_1(std::vector< aruco::Marker,std::allocator< aruco::Marker > > *self,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator pos,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type n,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &x){ self->insert(pos, n, x); } - - namespace swig { - template <> struct traits< aruco::Marker3DInfo > { - typedef pointer_category category; - static const char* type_name() { return"aruco::Marker3DInfo"; } - }; - } - - - namespace swig { - template <> struct traits > > { - typedef pointer_category category; - static const char* type_name() { - return "std::vector<" "aruco::Marker3DInfo" "," "std::allocator< aruco::Marker3DInfo >" " >"; - } - }; - } - -SWIGINTERN swig::SwigPyIterator *std_vector_Sl_aruco_Marker3DInfo_Sg__iterator(std::vector< aruco::Marker3DInfo > *self,PyObject **PYTHON_SELF){ - return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); - } -SWIGINTERN bool std_vector_Sl_aruco_Marker3DInfo_Sg____nonzero__(std::vector< aruco::Marker3DInfo > const *self){ - return !(self->empty()); - } -SWIGINTERN bool std_vector_Sl_aruco_Marker3DInfo_Sg____bool__(std::vector< aruco::Marker3DInfo > const *self){ - return !(self->empty()); - } -SWIGINTERN std::vector< aruco::Marker3DInfo >::size_type std_vector_Sl_aruco_Marker3DInfo_Sg____len__(std::vector< aruco::Marker3DInfo > const *self){ - return self->size(); - } -SWIGINTERN std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *std_vector_Sl_aruco_Marker3DInfo_Sg____getslice__(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j){ - return swig::getslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j){ - swig::setslice(self, i, j, 1, std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >()); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_1(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &v){ - swig::setslice(self, i, j, 1, v); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____delslice__(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::difference_type j){ - swig::delslice(self, i, j, 1); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i){ - swig::erase(self, swig::getpos(self, i)); - } -SWIGINTERN std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_0(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return NULL; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; - return swig::getslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_0(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &v){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; - swig::setslice(self, id, jd, step, v); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_1(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_1(std::vector< aruco::Marker3DInfo > *self,PySliceObject *slice){ - Py_ssize_t i, j, step; - if( !PySlice_Check(slice) ) { - SWIG_Error(SWIG_TypeError, "Slice object expected."); - return; - } - PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step); - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type id = i; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::difference_type jd = j; - swig::delslice(self, id, jd, step); - } -SWIGINTERN std::vector< aruco::Marker3DInfo >::value_type const &std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_1(std::vector< aruco::Marker3DInfo > const *self,std::vector< aruco::Marker3DInfo >::difference_type i){ - return *(swig::cgetpos(self, i)); - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_2(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::difference_type i,std::vector< aruco::Marker3DInfo >::value_type const &x){ - *(swig::getpos(self,i)) = x; - } -SWIGINTERN std::vector< aruco::Marker3DInfo >::value_type std_vector_Sl_aruco_Marker3DInfo_Sg__pop(std::vector< aruco::Marker3DInfo > *self){ - if (self->size() == 0) - throw std::out_of_range("pop from empty container"); - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >::value_type x = self->back(); - self->pop_back(); - return x; - } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg__append(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::value_type const &x){ - self->push_back(x); - } -SWIGINTERN std::vector< aruco::Marker3DInfo >::iterator std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator pos){ return self->erase(pos); } -SWIGINTERN std::vector< aruco::Marker3DInfo >::iterator std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_1(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator first,std::vector< aruco::Marker3DInfo >::iterator last){ return self->erase(first, last); } -SWIGINTERN std::vector< aruco::Marker3DInfo >::iterator std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_0(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator pos,std::vector< aruco::Marker3DInfo >::value_type const &x){ return self->insert(pos, x); } -SWIGINTERN void std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_1(std::vector< aruco::Marker3DInfo > *self,std::vector< aruco::Marker3DInfo >::iterator pos,std::vector< aruco::Marker3DInfo >::size_type n,std::vector< aruco::Marker3DInfo >::value_type const &x){ self->insert(pos, n, x); } - - #define SWIG_From_double PyFloat_FromDouble - - -SWIGINTERNINLINE PyObject * -SWIG_From_float (float value) -{ - return SWIG_From_double (value); -} - -SWIGINTERN cv::Point2f aruco_Marker___getitem__(aruco::Marker *self,int i){ - return self->at(i); - } - - -/* --------------------------------------------------- - * C++ director class methods - * --------------------------------------------------- */ - -#include "aruco_wrap.h" - -#ifdef __cplusplus -extern "C" { -#endif -SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = result; - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - size_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); - } - arg2 = static_cast< size_t >(val2); - try { - result = (swig::SwigPyIterator *)(arg1)->incr(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (swig::SwigPyIterator *)(arg1)->incr(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SwigPyIterator_incr__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SwigPyIterator_incr__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n" - " Possible C/C++ prototypes are:\n" - " swig::SwigPyIterator::incr(size_t)\n" - " swig::SwigPyIterator::incr()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - size_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); - } - arg2 = static_cast< size_t >(val2); - try { - result = (swig::SwigPyIterator *)(arg1)->decr(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (swig::SwigPyIterator *)(arg1)->decr(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SwigPyIterator_decr__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SwigPyIterator_decr__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n" - " Possible C/C++ prototypes are:\n" - " swig::SwigPyIterator::decr(size_t)\n" - " swig::SwigPyIterator::decr()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - ptrdiff_t result; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - try { - result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2); - } - catch(std::invalid_argument &_e) { - SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; - } - - resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - try { - result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2); - } - catch(std::invalid_argument &_e) { - SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; - } - - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)(arg1)->next(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = result; - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)(arg1)->__next__(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = result; - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)(arg1)->previous(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = result; - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *)(arg1)->advance(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - ptrdiff_t result; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); - resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SwigPyIterator___sub____SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SwigPyIterator___sub____SWIG_0(self, args); - } - } - } - -fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; -} - - -SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - PyObject **arg2 = (PyObject **) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - arg2 = &obj0; - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___bool__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::difference_type arg2 ; - std::vector< int >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< int,std::allocator< int > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); - } - arg2 = static_cast< std::vector< int >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); - } - arg3 = static_cast< std::vector< int >::difference_type >(val3); - try { - result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::difference_type arg2 ; - std::vector< int >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); - } - arg2 = static_cast< std::vector< int >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); - } - arg3 = static_cast< std::vector< int >::difference_type >(val3); - try { - std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::difference_type arg2 ; - std::vector< int >::difference_type arg3 ; - std::vector< int,std::allocator< int > > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - int res4 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); - } - arg2 = static_cast< std::vector< int >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); - } - arg3 = static_cast< std::vector< int >::difference_type >(val3); - { - std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; - res4 = swig::asptr(obj3, &ptr); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - arg4 = ptr; - } - try { - std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res4)) delete arg4; - return resultobj; -fail: - if (SWIG_IsNewObj(res4)) delete arg4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt___setslice____SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorInt___setslice____SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setslice__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n" - " std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::difference_type arg2 ; - std::vector< int >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); - } - arg2 = static_cast< std::vector< int >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); - } - arg3 = static_cast< std::vector< int >::difference_type >(val3); - try { - std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); - } - arg2 = static_cast< std::vector< int >::difference_type >(val2); - try { - std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< int,std::allocator< int > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - std::vector< int,std::allocator< int > > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res3 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - { - std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; - res3 = swig::asptr(obj2, &ptr); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - arg3 = ptr; - } - try { - std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res3)) delete arg3; - return resultobj; -fail: - if (SWIG_IsNewObj(res3)) delete arg3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___setitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_VectorInt___delitem____SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt___delitem____SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___delitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::__delitem__(std::vector< int >::difference_type)\n" - " std::vector< int >::__delitem__(PySliceObject *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< int >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); - } - arg2 = static_cast< std::vector< int >::difference_type >(val2); - try { - result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_From_int(static_cast< int >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_VectorInt___getitem____SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt___getitem____SWIG_1(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___getitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::__getitem__(PySliceObject *)\n" - " std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::difference_type arg2 ; - std::vector< int >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - std::vector< int >::value_type temp3 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); - } - arg2 = static_cast< std::vector< int >::difference_type >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); - } - temp3 = static_cast< std::vector< int >::value_type >(val3); - arg3 = &temp3; - try { - std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,arg2,(int const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_VectorInt___setitem____SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorInt___setitem____SWIG_0(self, args); - } - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt___setitem____SWIG_2(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n" - " std::vector< int >::__setitem__(PySliceObject *)\n" - " std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::value_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - try { - result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - std::vector< int >::value_type temp2 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); - } - temp2 = static_cast< std::vector< int >::value_type >(val2); - arg2 = &temp2; - std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail; - result = (std::vector< int > *)new std::vector< int >(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = 0 ; - int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - std::vector< int > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail; - { - std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; - res1 = swig::asptr(obj0, &ptr); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); - } - arg1 = ptr; - } - result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); - if (SWIG_IsNewObj(res1)) delete arg1; - return resultobj; -fail: - if (SWIG_IsNewObj(res1)) delete arg1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (bool)((std::vector< int > const *)arg1)->empty(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = ((std::vector< int > const *)arg1)->size(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); - } - arg2 = reinterpret_cast< std::vector< int > * >(argp2); - (arg1)->swap(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (arg1)->begin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (arg1)->end(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (arg1)->rbegin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (arg1)->rend(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - (arg1)->clear(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - SwigValueWrapper< std::allocator< int > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = ((std::vector< int > const *)arg1)->get_allocator(); - resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int >::size_type arg1 ; - size_t val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'"); - } - arg1 = static_cast< std::vector< int >::size_type >(val1); - result = (std::vector< int > *)new std::vector< int >(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - (arg1)->pop_back(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); - } - arg2 = static_cast< std::vector< int >::size_type >(val2); - (arg1)->resize(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::iterator arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< int >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } - } - result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,arg2); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::iterator arg2 ; - std::vector< int >::iterator arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - swig::SwigPyIterator *iter3 = 0 ; - int res3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< int >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } - } - res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res3) || !iter3) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); - if (iter_t) { - arg3 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'"); - } - } - result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,arg2,arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_VectorInt_erase__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_VectorInt_erase__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_erase'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::erase(std::vector< int >::iterator)\n" - " std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int >::size_type arg1 ; - std::vector< int >::value_type *arg2 = 0 ; - size_t val1 ; - int ecode1 = 0 ; - std::vector< int >::value_type temp2 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< int > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'"); - } - arg1 = static_cast< std::vector< int >::size_type >(val1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); - } - temp2 = static_cast< std::vector< int >::value_type >(val2); - arg2 = &temp2; - result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_VectorInt__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorInt__SWIG_2(self, args); - } - } - if (argc == 1) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorInt__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorInt__SWIG_3(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorInt'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::vector()\n" - " std::vector< int >::vector(std::vector< int > const &)\n" - " std::vector< int >::vector(std::vector< int >::size_type)\n" - " std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - std::vector< int >::value_type temp2 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); - } - temp2 = static_cast< std::vector< int >::value_type >(val2); - arg2 = &temp2; - (arg1)->push_back((std::vector< int >::value_type const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front(); - resultobj = SWIG_From_int(static_cast< int >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back(); - resultobj = SWIG_From_int(static_cast< int >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::size_type arg2 ; - std::vector< int >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - std::vector< int >::value_type temp3 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); - } - arg2 = static_cast< std::vector< int >::size_type >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); - } - temp3 = static_cast< std::vector< int >::value_type >(val3); - arg3 = &temp3; - (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::size_type arg2 ; - std::vector< int >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - std::vector< int >::value_type temp3 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); - } - arg2 = static_cast< std::vector< int >::size_type >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); - } - temp3 = static_cast< std::vector< int >::value_type >(val3); - arg3 = &temp3; - (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt_resize__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt_resize__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_resize'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::resize(std::vector< int >::size_type)\n" - " std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::iterator arg2 ; - std::vector< int >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - std::vector< int >::value_type temp3 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< int >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } - } - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); - } - temp3 = static_cast< std::vector< int >::value_type >(val3); - arg3 = &temp3; - result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,arg2,(int const &)*arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::iterator arg2 ; - std::vector< int >::size_type arg3 ; - std::vector< int >::value_type *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - size_t val3 ; - int ecode3 = 0 ; - std::vector< int >::value_type temp4 ; - int val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); - } - } - ecode3 = SWIG_AsVal_size_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'"); - } - arg3 = static_cast< std::vector< int >::size_type >(val3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'"); - } - temp4 = static_cast< std::vector< int >::value_type >(val4); - arg4 = &temp4; - std_vector_Sl_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(int const &)*arg4); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt_insert__SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorInt_insert__SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_insert'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n" - " std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - std::vector< int >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); - } - arg2 = static_cast< std::vector< int >::size_type >(val2); - (arg1)->reserve(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - result = ((std::vector< int > const *)arg1)->capacity(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< int > *arg1 = (std::vector< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector< int > *""'"); - } - arg1 = reinterpret_cast< std::vector< int > * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_CameraParameters_CameraMatrix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Mat arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_CameraMatrix_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CameraMatrix_set" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - if (arg1) (arg1)->CameraMatrix = arg2; - resultobj = SWIG_Py_Void(); - { - - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_CameraMatrix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_CameraMatrix_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CameraMatrix_get" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - result = ((arg1)->CameraMatrix); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_Distorsion_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Mat arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_Distorsion_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_Distorsion_set" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - if (arg1) (arg1)->Distorsion = arg2; - resultobj = SWIG_Py_Void(); - { - - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_Distorsion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_Distorsion_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_Distorsion_get" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - result = ((arg1)->Distorsion); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_CamSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Size arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_CamSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CamSize_set" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - if (arg1) (arg1)->CamSize = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_CamSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Size result; - - if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_CamSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_CamSize_get" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - result = ((arg1)->CamSize); - resultobj = SWIG_NewPointerObj((new cv::Size(static_cast< const cv::Size& >(result))), SWIGTYPE_p_cv__Size, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CameraParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_CameraParameters")) SWIG_fail; - result = (aruco::CameraParameters *)new aruco::CameraParameters(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CameraParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat arg1 ; - cv::Mat arg2 ; - cv::Size arg3 ; - cv::Mat *mat1 ; - cv::Mat *mat2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - aruco::CameraParameters *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:new_CameraParameters",&obj0,&obj1,&obj2)) SWIG_fail; - { - mat1 = array_to_mat(obj0); - if (mat1 == NULL) - SWIG_fail; - arg1 = *mat1; - } - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - { - arg3 = *array_to_size(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - result = (aruco::CameraParameters *)new aruco::CameraParameters(arg1,arg2,arg3); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_NEW | 0 ); - { - - } - { - - } - { - if (mat1 != NULL) - delete mat1; - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat1 != NULL) - delete mat1; - } - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Mat arg2 ; - cv::Mat arg3 ; - cv::Size arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - cv::Mat *mat3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:CameraParameters_setParams",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_setParams" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - { - mat3 = array_to_mat(obj2); - if (mat3 == NULL) - SWIG_fail; - arg3 = *mat3; - } - { - arg4 = *array_to_size(obj3); - if (&arg4 == NULL) - SWIG_fail; - } - (arg1)->setParams(arg2,arg3,arg4); - resultobj = SWIG_Py_Void(); - { - - } - { - - } - { - if (mat2 != NULL) - delete mat2; - } - { - if (mat3 != NULL) - delete mat3; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - { - if (mat3 != NULL) - delete mat3; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CameraParameters__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::CameraParameters *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_CameraParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraParameters" "', argument " "1"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraParameters" "', argument " "1"" of type '" "aruco::CameraParameters const &""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - result = (aruco::CameraParameters *)new aruco::CameraParameters((aruco::CameraParameters const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CameraParameters(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_CameraParameters__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_CameraParameters__SWIG_2(self, args); - } - } - if (argc == 3) { - int _v; - { - _v = is_array(argv[0]) || PySequence_Check(argv[0]); - } - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - return _wrap_new_CameraParameters__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CameraParameters'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::CameraParameters::CameraParameters()\n" - " aruco::CameraParameters::CameraParameters(cv::Mat,cv::Mat,cv::Size)\n" - " aruco::CameraParameters::CameraParameters(aruco::CameraParameters const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_isValid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_isValid" "', argument " "1"" of type '" "aruco::CameraParameters const *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - result = (bool)((aruco::CameraParameters const *)arg1)->isValid(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_saveToFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - std::string arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:CameraParameters_saveToFile",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_saveToFile" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CameraParameters_saveToFile" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - ecode3 = SWIG_AsVal_bool(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CameraParameters_saveToFile" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - (arg1)->saveToFile(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_saveToFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_saveToFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_saveToFile" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CameraParameters_saveToFile" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->saveToFile(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_saveToFile(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CameraParameters_saveToFile__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CameraParameters_saveToFile__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CameraParameters_saveToFile'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::CameraParameters::saveToFile(std::string,bool)\n" - " aruco::CameraParameters::saveToFile(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_readFromXMLFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_readFromXMLFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_readFromXMLFile" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CameraParameters_readFromXMLFile" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->readFromXMLFile(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Size arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_resize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_resize" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - (arg1)->resize(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_getCameraLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - cv::Mat *arg2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Point3f result; - - if (!PyArg_ParseTuple(args,(char *)"OO:CameraParameters_getCameraLocation",&obj0,&obj1)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - } - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - result = aruco::CameraParameters::getCameraLocation((cv::Mat const &)*arg1,(cv::Mat const &)*arg2); - { - PyObject* array = point3f_to_array(&result); - if (array == NULL) - SWIG_fail; - - resultobj = array; - } - { - - } - { - - } - { - if (arg1 != NULL) - delete arg1; - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_glGetProjectionMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Size arg2 ; - cv::Size arg3 ; - double *arg4 ; - double arg5 ; - double arg6 ; - bool arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CameraParameters_glGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - { - arg3 = *array_to_size(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - ecode5 = SWIG_AsVal_double(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_bool(obj6, &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); - (arg1)->glGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_glGetProjectionMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Size arg2 ; - cv::Size arg3 ; - double *arg4 ; - double arg5 ; - double arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CameraParameters_glGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - { - arg3 = *array_to_size(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - ecode5 = SWIG_AsVal_double(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_glGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - (arg1)->glGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_glGetProjectionMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 7) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CameraParameters_glGetProjectionMatrix__SWIG_1(self, args); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CameraParameters_glGetProjectionMatrix__SWIG_0(self, args); - } - } - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CameraParameters_glGetProjectionMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::CameraParameters::glGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double,bool)\n" - " aruco::CameraParameters::glGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Size arg2 ; - cv::Size arg3 ; - double *arg4 ; - double arg5 ; - double arg6 ; - bool arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CameraParameters_OgreGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - { - arg3 = *array_to_size(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - ecode5 = SWIG_AsVal_double(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_bool(obj6, &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); - (arg1)->OgreGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - cv::Size arg2 ; - cv::Size arg3 ; - double *arg4 ; - double arg5 ; - double arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CameraParameters_OgreGetProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - { - arg3 = *array_to_size(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "4"" of type '" "double [16]""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - ecode5 = SWIG_AsVal_double(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CameraParameters_OgreGetProjectionMatrix" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - (arg1)->OgreGetProjectionMatrix(arg2,arg3,arg4,arg5,arg6); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_OgreGetProjectionMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 7) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_1(self, args); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CameraParameters_OgreGetProjectionMatrix__SWIG_0(self, args); - } - } - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CameraParameters_OgreGetProjectionMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::CameraParameters::OgreGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double,bool)\n" - " aruco::CameraParameters::OgreGetProjectionMatrix(cv::Size,cv::Size,double [16],double,double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - cv::Mat *arg2 = 0 ; - int arg3 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:CameraParameters_getRTMatrix",&obj0,&obj1,&obj2)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - } - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CameraParameters_getRTMatrix" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - result = aruco::CameraParameters::getRTMatrix((cv::Mat const &)*arg1,(cv::Mat const &)*arg2,arg3); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - { - - } - { - - } - { - if (arg1 != NULL) - delete arg1; - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CameraParameters_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:CameraParameters_clear",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraParameters_clear" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - (arg1)->clear(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_CameraParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CameraParameters *arg1 = (aruco::CameraParameters *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_CameraParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CameraParameters, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraParameters" "', argument " "1"" of type '" "aruco::CameraParameters *""'"); - } - arg1 = reinterpret_cast< aruco::CameraParameters * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *CameraParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__CameraParameters, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - aruco::CameraParameters *arg2 = 0 ; - cv::Mat *arg3 = 0 ; - cv::Mat *arg4 = 0 ; - float arg5 ; - uchar *data_ptr1 ; - void *argp2 = 0 ; - int res2 = 0 ; - float val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr1 = arg1->data; - } - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); - { - arg3 = array_to_mat(obj2); - if (arg3 == NULL) - SWIG_fail; - } - { - arg4 = array_to_mat(obj3); - if (arg4 == NULL) - SWIG_fail; - } - ecode5 = SWIG_AsVal_float(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "5"" of type '" "float""'"); - } - arg5 = static_cast< float >(val5); - aruco::CvDrawingUtils::draw3dAxis(*arg1,(aruco::CameraParameters const &)*arg2,(cv::Mat const &)*arg3,(cv::Mat const &)*arg4,arg5); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr1 != arg1->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg1->rows, arg1->cols, arg1->type()); - SWIG_fail; - } - } - { - - } - { - - } - { - if (arg1 != NULL) - delete arg1; - } - { - if (arg3 != NULL) - delete arg3; - } - { - if (arg4 != NULL) - delete arg4; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - { - if (arg3 != NULL) - delete arg3; - } - { - if (arg4 != NULL) - delete arg4; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - int arg4 ; - uchar *data_ptr1 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - int val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr1 = arg1->data; - } - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); - } - arg2 = reinterpret_cast< Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - aruco::CvDrawingUtils::draw3dAxis(*arg1,*arg2,(aruco::CameraParameters const &)*arg3,arg4); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr1 != arg1->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg1->rows, arg1->cols, arg1->type()); - SWIG_fail; - } - } - { - if (arg1 != NULL) - delete arg1; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - uchar *data_ptr1 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:CvDrawingUtils_draw3dAxis",&obj0,&obj1,&obj2)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr1 = arg1->data; - } - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "2"" of type '" "Marker &""'"); - } - arg2 = reinterpret_cast< Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dAxis" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - aruco::CvDrawingUtils::draw3dAxis(*arg1,*arg2,(aruco::CameraParameters const &)*arg3); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr1 != arg1->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg1->rows, arg1->cols, arg1->type()); - SWIG_fail; - } - } - { - if (arg1 != NULL) - delete arg1; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dAxis(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - { - _v = is_array(argv[0]) || PySequence_Check(argv[0]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CvDrawingUtils_draw3dAxis__SWIG_2(self, args); - } - } - } - } - if (argc == 4) { - int _v; - { - _v = is_array(argv[0]) || PySequence_Check(argv[0]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CvDrawingUtils_draw3dAxis__SWIG_1(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - { - _v = is_array(argv[0]) || PySequence_Check(argv[0]); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - { - _v = true;//is_array(argv[3]) || PySequence_Check(argv[3]); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CvDrawingUtils_draw3dAxis__SWIG_0(self, args); - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CvDrawingUtils_draw3dAxis'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,aruco::CameraParameters const &,cv::Mat const &,cv::Mat const &,float)\n" - " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,Marker &,aruco::CameraParameters const &,int)\n" - " aruco::CvDrawingUtils::draw3dAxis(cv::Mat &,Marker &,aruco::CameraParameters const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - int arg4 ; - bool arg5 ; - uchar *data_ptr1 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvDrawingUtils_draw3dCube",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr1 = arg1->data; - } - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); - } - arg2 = reinterpret_cast< Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - aruco::CvDrawingUtils::draw3dCube(*arg1,*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr1 != arg1->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg1->rows, arg1->cols, arg1->type()); - SWIG_fail; - } - } - { - if (arg1 != NULL) - delete arg1; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - int arg4 ; - uchar *data_ptr1 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - int val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:CvDrawingUtils_draw3dCube",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr1 = arg1->data; - } - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); - } - arg2 = reinterpret_cast< Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - aruco::CvDrawingUtils::draw3dCube(*arg1,*arg2,(aruco::CameraParameters const &)*arg3,arg4); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr1 != arg1->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg1->rows, arg1->cols, arg1->type()); - SWIG_fail; - } - } - { - if (arg1 != NULL) - delete arg1; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cv::Mat *arg1 = 0 ; - Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - uchar *data_ptr1 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:CvDrawingUtils_draw3dCube",&obj0,&obj1,&obj2)) SWIG_fail; - { - arg1 = array_to_mat(obj0); - if (arg1 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr1 = arg1->data; - } - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "2"" of type '" "Marker &""'"); - } - arg2 = reinterpret_cast< Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDrawingUtils_draw3dCube" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - aruco::CvDrawingUtils::draw3dCube(*arg1,*arg2,(aruco::CameraParameters const &)*arg3); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr1 != arg1->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg1->rows, arg1->cols, arg1->type()); - SWIG_fail; - } - } - { - if (arg1 != NULL) - delete arg1; - } - return resultobj; -fail: - { - if (arg1 != NULL) - delete arg1; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CvDrawingUtils_draw3dCube(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - { - _v = is_array(argv[0]) || PySequence_Check(argv[0]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CvDrawingUtils_draw3dCube__SWIG_2(self, args); - } - } - } - } - if (argc == 4) { - int _v; - { - _v = is_array(argv[0]) || PySequence_Check(argv[0]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CvDrawingUtils_draw3dCube__SWIG_1(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - { - _v = is_array(argv[0]) || PySequence_Check(argv[0]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CvDrawingUtils_draw3dCube__SWIG_0(self, args); - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CvDrawingUtils_draw3dCube'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &,int,bool)\n" - " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &,int)\n" - " aruco::CvDrawingUtils::draw3dCube(cv::Mat &,Marker &,aruco::CameraParameters const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_CvDrawingUtils(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CvDrawingUtils *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_CvDrawingUtils")) SWIG_fail; - result = (aruco::CvDrawingUtils *)new aruco::CvDrawingUtils(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__CvDrawingUtils, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_CvDrawingUtils(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::CvDrawingUtils *arg1 = (aruco::CvDrawingUtils *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_CvDrawingUtils",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__CvDrawingUtils, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvDrawingUtils" "', argument " "1"" of type '" "aruco::CvDrawingUtils *""'"); - } - arg1 = reinterpret_cast< aruco::CvDrawingUtils * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *CvDrawingUtils_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__CvDrawingUtils, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_Debug_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - - if (!PyArg_ParseTuple(args,(char *)":Debug_init")) SWIG_fail; - aruco::Debug::init(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Debug_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Debug_setLevel",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Debug_setLevel" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - aruco::Debug::setLevel(arg1); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Debug_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int result; - - if (!PyArg_ParseTuple(args,(char *)":Debug_getLevel")) SWIG_fail; - result = (int)aruco::Debug::getLevel(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Debug_addString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Debug_addString",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Debug_addString" "', argument " "1"" of type '" "std::string &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Debug_addString" "', argument " "1"" of type '" "std::string &""'"); - } - arg1 = reinterpret_cast< std::string * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Debug_addString" "', argument " "2"" of type '" "std::string &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Debug_addString" "', argument " "2"" of type '" "std::string &""'"); - } - arg2 = reinterpret_cast< std::string * >(argp2); - aruco::Debug::addString(*arg1,*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Debug_getString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:Debug_getString",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Debug_getString" "', argument " "1"" of type '" "std::string &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Debug_getString" "', argument " "1"" of type '" "std::string &""'"); - } - arg1 = reinterpret_cast< std::string * >(argp1); - result = aruco::Debug::getString(*arg1); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Debug_getFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:Debug_getFileName",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Debug_getFileName" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::Debug::getFileName(arg1); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Debug *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Debug")) SWIG_fail; - result = (aruco::Debug *)new aruco::Debug(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Debug, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_Debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Debug *arg1 = (aruco::Debug *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_Debug",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Debug, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Debug" "', argument " "1"" of type '" "aruco::Debug *""'"); - } - arg1 = reinterpret_cast< aruco::Debug * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Debug_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Debug, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_Dictionary__is(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - uint64_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Dictionary__is",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary__is" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint64_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dictionary__is" "', argument " "2"" of type '" "uint64_t""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary__is" "', argument " "2"" of type '" "uint64_t""'"); - } else { - uint64_t * temp = reinterpret_cast< uint64_t * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - result = (bool)((aruco::Dictionary const *)arg1)->is(arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::Dictionary::DICT_TYPES result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getType" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - result = (aruco::Dictionary::DICT_TYPES)((aruco::Dictionary const *)arg1)->getType(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - uint64_t result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_size" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - result = ((aruco::Dictionary const *)arg1)->size(); - resultobj = SWIG_NewPointerObj((new uint64_t(static_cast< const uint64_t& >(result))), SWIGTYPE_p_uint64_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_nbits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - uint32_t result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_nbits",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_nbits" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - result = ((aruco::Dictionary const *)arg1)->nbits(); - resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_tau(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - uint32_t result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_tau",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_tau" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - result = ((aruco::Dictionary const *)arg1)->tau(); - resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getName" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - result = ((aruco::Dictionary const *)arg1)->getName(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getMapCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::map< uint64_t,uint16_t > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getMapCode",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMapCode" "', argument " "1"" of type '" "aruco::Dictionary const *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - result = (std::map< uint64_t,uint16_t > *) &((aruco::Dictionary const *)arg1)->getMapCode(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_uint64_t_uint16_t_t, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - uint64_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Dictionary_at",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_at" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint64_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dictionary_at" "', argument " "2"" of type '" "uint64_t""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_at" "', argument " "2"" of type '" "uint64_t""'"); - } else { - uint64_t * temp = reinterpret_cast< uint64_t * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - result = (int)(arg1)->at(arg2); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - bool arg5 ; - bool arg6 ; - bool arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - bool val6 ; - int ecode6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dictionary_getMarkerImage_id" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_bool(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dictionary_getMarkerImage_id" "', argument " "6"" of type '" "bool""'"); - } - arg6 = static_cast< bool >(val6); - ecode7 = SWIG_AsVal_bool(obj6, &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Dictionary_getMarkerImage_id" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); - result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5,arg6,arg7); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - bool arg5 ; - bool arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - bool val6 ; - int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dictionary_getMarkerImage_id" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_bool(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dictionary_getMarkerImage_id" "', argument " "6"" of type '" "bool""'"); - } - arg6 = static_cast< bool >(val6); - result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5,arg6); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dictionary_getMarkerImage_id" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - result = (arg1)->getMarkerImage_id(arg2,arg3,arg4,arg5); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_getMarkerImage_id" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - result = (arg1)->getMarkerImage_id(arg2,arg3,arg4); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Dictionary_getMarkerImage_id",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getMarkerImage_id" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dictionary_getMarkerImage_id" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getMarkerImage_id" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - result = (arg1)->getMarkerImage_id(arg2,arg3); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getMarkerImage_id(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 7) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_4(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_3(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_2(self, args); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_1(self, args); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Dictionary_getMarkerImage_id__SWIG_0(self, args); - } - } - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_getMarkerImage_id'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool,bool,bool)\n" - " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool,bool)\n" - " aruco::Dictionary::getMarkerImage_id(int,int,bool,bool)\n" - " aruco::Dictionary::getMarkerImage_id(int,int,bool)\n" - " aruco::Dictionary::getMarkerImage_id(int,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_createMarkerMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - cv::Size arg2 ; - int arg3 ; - int arg4 ; - std::vector< int,std::allocator< int > > *arg5 = 0 ; - bool arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - int res5 = SWIG_OLDOBJ ; - bool val6 ; - int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - aruco::MarkerMap result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Dictionary_createMarkerMap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_createMarkerMap" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_createMarkerMap" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_createMarkerMap" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - { - std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; - res5 = swig::asptr(obj4, &ptr); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - arg5 = ptr; - } - ecode6 = SWIG_AsVal_bool(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dictionary_createMarkerMap" "', argument " "6"" of type '" "bool""'"); - } - arg6 = static_cast< bool >(val6); - result = (arg1)->createMarkerMap(arg2,arg3,arg4,(std::vector< int,std::allocator< int > > const &)*arg5,arg6); - resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); - if (SWIG_IsNewObj(res5)) delete arg5; - return resultobj; -fail: - if (SWIG_IsNewObj(res5)) delete arg5; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_createMarkerMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - cv::Size arg2 ; - int arg3 ; - int arg4 ; - std::vector< int,std::allocator< int > > *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - int res5 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - aruco::MarkerMap result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Dictionary_createMarkerMap",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_createMarkerMap" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - { - arg2 = *array_to_size(obj1); - if (&arg2 == NULL) - SWIG_fail; - } - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_createMarkerMap" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dictionary_createMarkerMap" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - { - std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; - res5 = swig::asptr(obj4, &ptr); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_createMarkerMap" "', argument " "5"" of type '" "std::vector< int,std::allocator< int > > const &""'"); - } - arg5 = ptr; - } - result = (arg1)->createMarkerMap(arg2,arg3,arg4,(std::vector< int,std::allocator< int > > const &)*arg5); - resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); - if (SWIG_IsNewObj(res5)) delete arg5; - return resultobj; -fail: - if (SWIG_IsNewObj(res5)) delete arg5; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_createMarkerMap(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = swig::asptr(argv[4], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Dictionary_createMarkerMap__SWIG_1(self, args); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Dictionary, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = swig::asptr(argv[4], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Dictionary_createMarkerMap__SWIG_0(self, args); - } - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_createMarkerMap'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Dictionary::createMarkerMap(cv::Size,int,int,std::vector< int,std::allocator< int > > const &,bool)\n" - " aruco::Dictionary::createMarkerMap(cv::Size,int,int,std::vector< int,std::allocator< int > > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_loadPredefined__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary::DICT_TYPES arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - aruco::Dictionary result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_loadPredefined",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Dictionary_loadPredefined" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); - } - arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); - result = aruco::Dictionary::loadPredefined(arg1); - resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_loadPredefined__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::Dictionary result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_loadPredefined",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_loadPredefined" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::Dictionary::loadPredefined(arg1); - resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_loadPredefined(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Dictionary_loadPredefined__SWIG_0(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Dictionary_loadPredefined__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_loadPredefined'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Dictionary::loadPredefined(aruco::Dictionary::DICT_TYPES)\n" - " aruco::Dictionary::loadPredefined(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_loadFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::Dictionary result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_loadFromFile",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_loadFromFile" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::Dictionary::loadFromFile(arg1); - resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::Dictionary result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_load",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_load" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::Dictionary::load(arg1); - resultobj = SWIG_NewPointerObj((new aruco::Dictionary(static_cast< const aruco::Dictionary& >(result))), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_computeDictionaryDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - uint64_t result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_computeDictionaryDistance",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__Dictionary, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_computeDictionaryDistance" "', argument " "1"" of type '" "aruco::Dictionary const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_computeDictionaryDistance" "', argument " "1"" of type '" "aruco::Dictionary const &""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - result = aruco::Dictionary::computeDictionaryDistance((aruco::Dictionary const &)*arg1); - resultobj = SWIG_NewPointerObj((new uint64_t(static_cast< const uint64_t& >(result))), SWIGTYPE_p_uint64_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::Dictionary::DICT_TYPES result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getTypeFromString",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_getTypeFromString" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::Dictionary::DICT_TYPES)aruco::Dictionary::getTypeFromString(arg1); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getTypeString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary::DICT_TYPES arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getTypeString",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Dictionary_getTypeString" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); - } - arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); - result = aruco::Dictionary::getTypeString(arg1); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_isPredefinedDictinaryString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_isPredefinedDictinaryString",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Dictionary_isPredefinedDictinaryString" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (bool)aruco::Dictionary::isPredefinedDictinaryString(arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Dictionary_getDicTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SwigValueWrapper< std::vector< std::string,std::allocator< std::string > > > result; - - if (!PyArg_ParseTuple(args,(char *)":Dictionary_getDicTypes")) SWIG_fail; - result = aruco::Dictionary::getDicTypes(); - resultobj = SWIG_NewPointerObj((new std::vector< std::string,std::allocator< std::string > >(static_cast< const std::vector< std::string,std::allocator< std::string > >& >(result))), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Dictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Dictionary")) SWIG_fail; - result = (aruco::Dictionary *)new aruco::Dictionary(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_Dictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary *arg1 = (aruco::Dictionary *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_Dictionary",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Dictionary, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dictionary" "', argument " "1"" of type '" "aruco::Dictionary *""'"); - } - arg1 = reinterpret_cast< aruco::Dictionary * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Dictionary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Dictionary, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_Point2fVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - PyObject **arg2 = (PyObject **) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - arg2 = &obj0; - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_iterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_iterator" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (swig::SwigPyIterator *)std_vector_Sl_cv_Point2f_Sg__iterator(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec___nonzero__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___nonzero__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (bool)std_vector_Sl_cv_Point2f_Sg____nonzero__((std::vector< cv::Point2f > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec___bool__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___bool__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (bool)std_vector_Sl_cv_Point2f_Sg____bool__((std::vector< cv::Point2f > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec___len__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___len__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = std_vector_Sl_cv_Point2f_Sg____len__((std::vector< cv::Point2f > const *)arg1); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::difference_type arg2 ; - std::vector< cv::Point2f >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___getslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___getslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___getslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); - try { - result = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)std_vector_Sl_cv_Point2f_Sg____getslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::difference_type arg2 ; - std::vector< cv::Point2f >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___setslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___setslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); - try { - std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_0(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::difference_type arg2 ; - std::vector< cv::Point2f >::difference_type arg3 ; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - int res4 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:Point2fVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___setslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___setslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); - { - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; - res4 = swig::asptr(obj3, &ptr); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Point2fVec___setslice__" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec___setslice__" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - arg4 = ptr; - } - try { - std_vector_Sl_cv_Point2f_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg4); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res4)) delete arg4; - return resultobj; -fail: - if (SWIG_IsNewObj(res4)) delete arg4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___setslice__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Point2fVec___setslice____SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = swig::asptr(argv[3], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Point2fVec___setslice____SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___setslice__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::__setslice__(std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f >::difference_type)\n" - " std::vector< cv::Point2f >::__setslice__(std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::difference_type arg2 ; - std::vector< cv::Point2f >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___delslice__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___delslice__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec___delslice__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg3 = static_cast< std::vector< cv::Point2f >::difference_type >(val3); - try { - std_vector_Sl_cv_Point2f_Sg____delslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___delitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___delitem__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); - try { - std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___getitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - result = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res3 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - { - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; - res3 = swig::asptr(obj2, &ptr); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - arg3 = ptr; - } - try { - std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res3)) delete arg3; - return resultobj; -fail: - if (SWIG_IsNewObj(res3)) delete arg3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___setitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___delitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_cv_Point2f_Sg____delitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___delitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_Point2fVec___delitem____SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Point2fVec___delitem____SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___delitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::__delitem__(std::vector< cv::Point2f >::difference_type)\n" - " std::vector< cv::Point2f >::__delitem__(PySliceObject *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< cv::Point2f >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___getitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___getitem__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); - try { - result = (std::vector< cv::Point2f >::value_type *) &std_vector_Sl_cv_Point2f_Sg____getitem____SWIG_1((std::vector< cv::Point2f > const *)arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Point2f, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___getitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_Point2fVec___getitem____SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Point2fVec___getitem____SWIG_1(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___getitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::__getitem__(PySliceObject *)\n" - " std::vector< cv::Point2f >::__getitem__(std::vector< cv::Point2f >::difference_type) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::difference_type arg2 ; - std::vector< cv::Point2f >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec___setitem__" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec___setitem__" "', argument " "2"" of type '" "std::vector< cv::Point2f >::difference_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::difference_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec___setitem__" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); - try { - std_vector_Sl_cv_Point2f_Sg____setitem____SWIG_2(arg1,arg2,(cv::Point2f const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec___setitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_Point2fVec___setitem____SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - int res = swig::asptr(argv[2], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Point2fVec___setitem____SWIG_0(self, args); - } - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Point2f, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Point2fVec___setitem____SWIG_2(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec___setitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::__setitem__(PySliceObject *,std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)\n" - " std::vector< cv::Point2f >::__setitem__(PySliceObject *)\n" - " std::vector< cv::Point2f >::__setitem__(std::vector< cv::Point2f >::difference_type,std::vector< cv::Point2f >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::value_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_pop",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_pop" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - try { - result = std_vector_Sl_cv_Point2f_Sg__pop(arg1); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - { - PyObject* array = point2f_to_array(&result); - if (array == NULL) - SWIG_fail; - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_append",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_append" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point2fVec_append" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_append" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp2); - std_vector_Sl_cv_Point2f_Sg__append(arg1,(cv::Point2f const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Point2fVec")) SWIG_fail; - result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = 0 ; - int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_Point2fVec",&obj0)) SWIG_fail; - { - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; - res1 = swig::asptr(obj0, &ptr); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f > const &""'"); - } - arg1 = ptr; - } - result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >((std::vector< cv::Point2f > const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); - if (SWIG_IsNewObj(res1)) delete arg1; - return resultobj; -fail: - if (SWIG_IsNewObj(res1)) delete arg1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_empty",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_empty" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (bool)((std::vector< cv::Point2f > const *)arg1)->empty(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_size" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = ((std::vector< cv::Point2f > const *)arg1)->size(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_swap",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_swap" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point2fVec_swap" "', argument " "2"" of type '" "std::vector< cv::Point2f > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_swap" "', argument " "2"" of type '" "std::vector< cv::Point2f > &""'"); - } - arg2 = reinterpret_cast< std::vector< cv::Point2f > * >(argp2); - (arg1)->swap(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_begin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_begin" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (arg1)->begin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_end",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_end" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (arg1)->end(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_rbegin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_rbegin" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (arg1)->rbegin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_rend",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_rend" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (arg1)->rend(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_clear",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_clear" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - (arg1)->clear(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - SwigValueWrapper< std::allocator< cv::Point2f > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_get_allocator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_get_allocator" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = ((std::vector< cv::Point2f > const *)arg1)->get_allocator(); - resultobj = SWIG_NewPointerObj((new std::vector< cv::Point2f >::allocator_type(static_cast< const std::vector< cv::Point2f >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cv__Point2f_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f >::size_type arg1 ; - size_t val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_Point2fVec",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f >::size_type""'"); - } - arg1 = static_cast< std::vector< cv::Point2f >::size_type >(val1); - result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_pop_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_pop_back" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - (arg1)->pop_back(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_resize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_resize" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_resize" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); - (arg1)->resize(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::iterator arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< cv::Point2f >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_erase",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_erase" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } - } - result = std_vector_Sl_cv_Point2f_Sg__erase__SWIG_0(arg1,arg2); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::iterator arg2 ; - std::vector< cv::Point2f >::iterator arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - swig::SwigPyIterator *iter3 = 0 ; - int res3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< cv::Point2f >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_erase",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_erase" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } - } - res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res3) || !iter3) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "3"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); - if (iter_t) { - arg3 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_erase" "', argument " "3"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } - } - result = std_vector_Sl_cv_Point2f_Sg__erase__SWIG_1(arg1,arg2,arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_erase(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_Point2fVec_erase__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_Point2fVec_erase__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec_erase'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::erase(std::vector< cv::Point2f >::iterator)\n" - " std::vector< cv::Point2f >::erase(std::vector< cv::Point2f >::iterator,std::vector< cv::Point2f >::iterator)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_Point2fVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f >::size_type arg1 ; - std::vector< cv::Point2f >::value_type *arg2 = 0 ; - size_t val1 ; - int ecode1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< cv::Point2f > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_Point2fVec",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f >::size_type""'"); - } - arg1 = static_cast< std::vector< cv::Point2f >::size_type >(val1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Point2fVec" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Point2fVec" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp2); - result = (std::vector< cv::Point2f > *)new std::vector< cv::Point2f >(arg1,(std::vector< cv::Point2f >::value_type const &)*arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Point2fVec(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_Point2fVec__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Point2fVec__SWIG_2(self, args); - } - } - if (argc == 1) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Point2fVec__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Point2f, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Point2fVec__SWIG_3(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Point2fVec'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::vector()\n" - " std::vector< cv::Point2f >::vector(std::vector< cv::Point2f > const &)\n" - " std::vector< cv::Point2f >::vector(std::vector< cv::Point2f >::size_type)\n" - " std::vector< cv::Point2f >::vector(std::vector< cv::Point2f >::size_type,std::vector< cv::Point2f >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_push_back",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_push_back" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point2fVec_push_back" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_push_back" "', argument " "2"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp2); - (arg1)->push_back((std::vector< cv::Point2f >::value_type const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_front",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_front" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (std::vector< cv::Point2f >::value_type *) &((std::vector< cv::Point2f > const *)arg1)->front(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Point2f, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_back" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = (std::vector< cv::Point2f >::value_type *) &((std::vector< cv::Point2f > const *)arg1)->back(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Point2f, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::size_type arg2 ; - std::vector< cv::Point2f >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_assign",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_assign" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_assign" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec_assign" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_assign" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); - (arg1)->assign(arg2,(std::vector< cv::Point2f >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::size_type arg2 ; - std::vector< cv::Point2f >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_resize",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_resize" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_resize" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec_resize" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_resize" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); - (arg1)->resize(arg2,(std::vector< cv::Point2f >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_resize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Point2fVec_resize__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Point2f, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Point2fVec_resize__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec_resize'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::resize(std::vector< cv::Point2f >::size_type)\n" - " std::vector< cv::Point2f >::resize(std::vector< cv::Point2f >::size_type,std::vector< cv::Point2f >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::iterator arg2 ; - std::vector< cv::Point2f >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< cv::Point2f >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Point2fVec_insert",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_insert" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Point2fVec_insert" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_insert" "', argument " "3"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp3); - result = std_vector_Sl_cv_Point2f_Sg__insert__SWIG_0(arg1,arg2,(cv::Point2f const &)*arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< cv::Point2f >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::iterator arg2 ; - std::vector< cv::Point2f >::size_type arg3 ; - std::vector< cv::Point2f >::value_type *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - size_t val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:Point2fVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_insert" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Point2fVec_insert" "', argument " "2"" of type '" "std::vector< cv::Point2f >::iterator""'"); - } - } - ecode3 = SWIG_AsVal_size_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2fVec_insert" "', argument " "3"" of type '" "std::vector< cv::Point2f >::size_type""'"); - } - arg3 = static_cast< std::vector< cv::Point2f >::size_type >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Point2fVec_insert" "', argument " "4"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Point2fVec_insert" "', argument " "4"" of type '" "std::vector< cv::Point2f >::value_type const &""'"); - } - arg4 = reinterpret_cast< std::vector< cv::Point2f >::value_type * >(argp4); - std_vector_Sl_cv_Point2f_Sg__insert__SWIG_1(arg1,arg2,arg3,(cv::Point2f const &)*arg4); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_insert(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Point2f, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Point2fVec_insert__SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cv__Point2f, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Point2fVec_insert__SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Point2fVec_insert'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< cv::Point2f >::insert(std::vector< cv::Point2f >::iterator,std::vector< cv::Point2f >::value_type const &)\n" - " std::vector< cv::Point2f >::insert(std::vector< cv::Point2f >::iterator,std::vector< cv::Point2f >::size_type,std::vector< cv::Point2f >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - std::vector< cv::Point2f >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Point2fVec_reserve",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_reserve" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2fVec_reserve" "', argument " "2"" of type '" "std::vector< cv::Point2f >::size_type""'"); - } - arg2 = static_cast< std::vector< cv::Point2f >::size_type >(val2); - (arg1)->reserve(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Point2fVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point2f >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:Point2fVec_capacity",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2fVec_capacity" "', argument " "1"" of type '" "std::vector< cv::Point2f > const *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - result = ((std::vector< cv::Point2f > const *)arg1)->capacity(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_Point2fVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f > *arg1 = (std::vector< cv::Point2f > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_Point2fVec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2fVec" "', argument " "1"" of type '" "std::vector< cv::Point2f > *""'"); - } - arg1 = reinterpret_cast< std::vector< cv::Point2f > * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Point2fVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_MarkerVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - PyObject **arg2 = (PyObject **) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - arg2 = &obj0; - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_iterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_iterator" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (swig::SwigPyIterator *)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__iterator(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec___nonzero__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___nonzero__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (bool)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____nonzero__((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec___bool__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___bool__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (bool)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____bool__((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec___len__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___len__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____len__((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___getslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___getslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___getslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); - try { - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - int res4 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res4 = swig::asptr(obj3, &ptr); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerVec___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg4 = ptr; - } - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg4); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res4)) delete arg4; - return resultobj; -fail: - if (SWIG_IsNewObj(res4)) delete arg4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___setslice__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerVec___setslice____SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = swig::asptr(argv[3], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerVec___setslice____SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___setslice__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setslice__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___delslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___delslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec___delslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val3); - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___delitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res3 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res3 = swig::asptr(obj2, &ptr); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg3 = ptr; - } - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res3)) delete arg3; - return resultobj; -fail: - if (SWIG_IsNewObj(res3)) delete arg3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___setitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____delitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___delitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_MarkerVec___delitem____SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerVec___delitem____SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___delitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__delitem__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__delitem__(PySliceObject *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___getitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); - try { - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *) &std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____getitem____SWIG_1((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___getitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_MarkerVec___getitem____SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerVec___getitem____SWIG_1(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___getitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__getitem__(PySliceObject *)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__getitem__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec___setitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); - try { - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg____setitem____SWIG_2(arg1,arg2,(aruco::Marker const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec___setitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_MarkerVec___setitem____SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - int res = swig::asptr(argv[2], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerVec___setitem____SWIG_0(self, args); - } - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerVec___setitem____SWIG_2(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec___setitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setitem__(PySliceObject *,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setitem__(PySliceObject *)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::__setitem__(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::difference_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_pop",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_pop" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - try { - result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__pop(arg1); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type& >(result))), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_append",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_append" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerVec_append" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_append" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp2); - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__append(arg1,(aruco::Marker const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_MarkerVec")) SWIG_fail; - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = 0 ; - int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerVec",&obj0)) SWIG_fail; - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res1 = swig::asptr(obj0, &ptr); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg1 = ptr; - } - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); - if (SWIG_IsNewObj(res1)) delete arg1; - return resultobj; -fail: - if (SWIG_IsNewObj(res1)) delete arg1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_empty",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_empty" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (bool)((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->empty(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_size" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = ((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->size(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_swap",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_swap" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerVec_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp2); - (arg1)->swap(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_begin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_begin" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (arg1)->begin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_end",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_end" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (arg1)->end(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_rbegin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_rbegin" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (arg1)->rbegin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_rend",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_rend" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (arg1)->rend(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_clear",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_clear" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - (arg1)->clear(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - SwigValueWrapper< std::allocator< aruco::Marker > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_get_allocator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_get_allocator" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = ((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->get_allocator(); - resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker,std::allocator< aruco::Marker > >::allocator_type(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_aruco__Marker_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg1 ; - size_t val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerVec",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); - } - arg1 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val1); - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_pop_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_pop_back" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - (arg1)->pop_back(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_resize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); - (arg1)->resize(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_erase",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } else { - swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } - } - result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_0(arg1,arg2); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - swig::SwigPyIterator *iter3 = 0 ; - int res3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_erase",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } else { - swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } - } - res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res3) || !iter3) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } else { - swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter3); - if (iter_t) { - arg3 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } - } - result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__erase__SWIG_1(arg1,arg2,arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_erase(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_MarkerVec_erase__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_MarkerVec_erase__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec_erase'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::erase(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::erase(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg1 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg2 = 0 ; - size_t val1 ; - int ecode1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_MarkerVec",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); - } - arg1 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MarkerVec" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkerVec" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp2); - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)new std::vector< aruco::Marker,std::allocator< aruco::Marker > >(arg1,(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerVec(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_MarkerVec__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MarkerVec__SWIG_2(self, args); - } - } - if (argc == 1) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MarkerVec__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MarkerVec__SWIG_3(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerVec'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector()\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::vector(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_push_back",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_push_back" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerVec_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp2); - (arg1)->push_back((std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_front",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_front" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *) &((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->front(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_back" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = (std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *) &((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->back(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_assign",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_assign" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_assign" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); - (arg1)->assign(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_resize",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); - (arg1)->resize(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_resize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerVec_resize__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerVec_resize__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec_resize'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::resize(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::resize(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerVec_insert",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } else { - swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerVec_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp3); - result = std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_0(arg1,arg2,(aruco::Marker const &)*arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg3 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - size_t val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } else { - swig::SwigPyIterator_T >::iterator > *iter_t = dynamic_cast >::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MarkerVec_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator""'"); - } - } - ecode3 = SWIG_AsVal_size_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerVec_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerVec_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerVec_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &""'"); - } - arg4 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type * >(argp4); - std_vector_Sl_aruco_Marker_Sc_std_allocator_Sl_aruco_Marker_Sg__Sg__insert__SWIG_1(arg1,arg2,arg3,(aruco::Marker const &)*arg4); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_insert(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerVec_insert__SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast >::iterator > *>(iter) != 0)); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerVec_insert__SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerVec_insert'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::insert(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n" - " std::vector< aruco::Marker,std::allocator< aruco::Marker > >::insert(std::vector< aruco::Marker,std::allocator< aruco::Marker > >::iterator,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type,std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerVec_reserve",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_reserve" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerVec_reserve" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type >(val2); - (arg1)->reserve(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerVec_capacity",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerVec_capacity" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - result = ((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const *)arg1)->capacity(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MarkerVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg1 = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerVec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerVec" "', argument " "1"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MarkerVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - PyObject **arg2 = (PyObject **) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - arg2 = &obj0; - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_iterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_iterator" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (swig::SwigPyIterator *)std_vector_Sl_aruco_Marker3DInfo_Sg__iterator(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo___nonzero__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___nonzero__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (bool)std_vector_Sl_aruco_Marker3DInfo_Sg____nonzero__((std::vector< aruco::Marker3DInfo > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo___bool__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___bool__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (bool)std_vector_Sl_aruco_Marker3DInfo_Sg____bool__((std::vector< aruco::Marker3DInfo > const *)arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo___len__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___len__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = std_vector_Sl_aruco_Marker3DInfo_Sg____len__((std::vector< aruco::Marker3DInfo > const *)arg1); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::difference_type arg2 ; - std::vector< aruco::Marker3DInfo >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___getslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___getslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___getslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); - try { - result = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)std_vector_Sl_aruco_Marker3DInfo_Sg____getslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::difference_type arg2 ; - std::vector< aruco::Marker3DInfo >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_0(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::difference_type arg2 ; - std::vector< aruco::Marker3DInfo >::difference_type arg3 ; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - int res4 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorMarker3DInfo___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); - { - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *ptr = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)0; - res4 = swig::asptr(obj3, &ptr); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMarker3DInfo___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo___setslice__" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); - } - arg4 = ptr; - } - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)*arg4); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res4)) delete arg4; - return resultobj; -fail: - if (SWIG_IsNewObj(res4)) delete arg4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setslice__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorMarker3DInfo___setslice____SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = swig::asptr(argv[3], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorMarker3DInfo___setslice____SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___setslice__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::__setslice__(std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo >::difference_type)\n" - " std::vector< aruco::Marker3DInfo >::__setslice__(std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::difference_type arg2 ; - std::vector< aruco::Marker3DInfo >::difference_type arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - ptrdiff_t val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___delslice__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___delslice__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); - ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo___delslice__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val3); - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____delslice__(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - result = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_0(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res3 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - { - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *ptr = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)0; - res3 = swig::asptr(obj2, &ptr); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &""'"); - } - arg3 = ptr; - } - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res3)) delete arg3; - return resultobj; -fail: - if (SWIG_IsNewObj(res3)) delete arg3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___setitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - PySliceObject *arg2 = (PySliceObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - { - if (!PySlice_Check(obj1)) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); - } - arg2 = (PySliceObject *) obj1; - } - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____delitem____SWIG_1(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - catch(std::invalid_argument &_e) { - SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___delitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_VectorMarker3DInfo___delitem____SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorMarker3DInfo___delitem____SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___delitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::__delitem__(std::vector< aruco::Marker3DInfo >::difference_type)\n" - " std::vector< aruco::Marker3DInfo >::__delitem__(PySliceObject *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::difference_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker3DInfo >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___getitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); - try { - result = (std::vector< aruco::Marker3DInfo >::value_type *) &std_vector_Sl_aruco_Marker3DInfo_Sg____getitem____SWIG_1((std::vector< aruco::Marker3DInfo > const *)arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___getitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_VectorMarker3DInfo___getitem____SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorMarker3DInfo___getitem____SWIG_1(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___getitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::__getitem__(PySliceObject *)\n" - " std::vector< aruco::Marker3DInfo >::__getitem__(std::vector< aruco::Marker3DInfo >::difference_type) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::difference_type arg2 ; - std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::difference_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::difference_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo___setitem__" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); - try { - std_vector_Sl_aruco_Marker3DInfo_Sg____setitem____SWIG_2(arg1,arg2,(aruco::Marker3DInfo const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo___setitem__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - return _wrap_VectorMarker3DInfo___setitem____SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PySlice_Check(argv[1]); - } - if (_v) { - int res = swig::asptr(argv[2], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorMarker3DInfo___setitem____SWIG_0(self, args); - } - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorMarker3DInfo___setitem____SWIG_2(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo___setitem__'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::__setitem__(PySliceObject *,std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > const &)\n" - " std::vector< aruco::Marker3DInfo >::__setitem__(PySliceObject *)\n" - " std::vector< aruco::Marker3DInfo >::__setitem__(std::vector< aruco::Marker3DInfo >::difference_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::value_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_pop",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_pop" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - try { - result = std_vector_Sl_aruco_Marker3DInfo_Sg__pop(arg1); - } - catch(std::out_of_range &_e) { - SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); - } - - resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker3DInfo >::value_type(static_cast< const std::vector< aruco::Marker3DInfo >::value_type& >(result))), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_append",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_append" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMarker3DInfo_append" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_append" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp2); - std_vector_Sl_aruco_Marker3DInfo_Sg__append(arg1,(aruco::Marker3DInfo const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_VectorMarker3DInfo")) SWIG_fail; - result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = 0 ; - int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_VectorMarker3DInfo",&obj0)) SWIG_fail; - { - std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *ptr = (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *)0; - res1 = swig::asptr(obj0, &ptr); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const &""'"); - } - arg1 = ptr; - } - result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >((std::vector< aruco::Marker3DInfo > const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); - if (SWIG_IsNewObj(res1)) delete arg1; - return resultobj; -fail: - if (SWIG_IsNewObj(res1)) delete arg1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_empty",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_empty" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (bool)((std::vector< aruco::Marker3DInfo > const *)arg1)->empty(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_size" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = ((std::vector< aruco::Marker3DInfo > const *)arg1)->size(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_swap",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_swap" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMarker3DInfo_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_swap" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo > &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp2); - (arg1)->swap(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_begin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_begin" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (arg1)->begin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_end",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_end" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (arg1)->end(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_rbegin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_rbegin" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (arg1)->rbegin(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::reverse_iterator result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_rend",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_rend" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (arg1)->rend(); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::reverse_iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_clear",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_clear" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - (arg1)->clear(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - SwigValueWrapper< std::allocator< aruco::Marker3DInfo > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_get_allocator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_get_allocator" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = ((std::vector< aruco::Marker3DInfo > const *)arg1)->get_allocator(); - resultobj = SWIG_NewPointerObj((new std::vector< aruco::Marker3DInfo >::allocator_type(static_cast< const std::vector< aruco::Marker3DInfo >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_aruco__Marker3DInfo_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo >::size_type arg1 ; - size_t val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_VectorMarker3DInfo",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); - } - arg1 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val1); - result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_pop_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_pop_back" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - (arg1)->pop_back(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_resize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); - (arg1)->resize(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::iterator arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker3DInfo >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_erase",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } - } - result = std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_0(arg1,arg2); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::iterator arg2 ; - std::vector< aruco::Marker3DInfo >::iterator arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - swig::SwigPyIterator *iter3 = 0 ; - int res3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< aruco::Marker3DInfo >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_erase",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_erase" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } - } - res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res3) || !iter3) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); - if (iter_t) { - arg3 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_erase" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } - } - result = std_vector_Sl_aruco_Marker3DInfo_Sg__erase__SWIG_1(arg1,arg2,arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_erase(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_VectorMarker3DInfo_erase__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - return _wrap_VectorMarker3DInfo_erase__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo_erase'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::erase(std::vector< aruco::Marker3DInfo >::iterator)\n" - " std::vector< aruco::Marker3DInfo >::erase(std::vector< aruco::Marker3DInfo >::iterator,std::vector< aruco::Marker3DInfo >::iterator)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo >::size_type arg1 ; - std::vector< aruco::Marker3DInfo >::value_type *arg2 = 0 ; - size_t val1 ; - int ecode1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker3DInfo > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorMarker3DInfo",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); - } - arg1 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMarker3DInfo" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMarker3DInfo" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp2); - result = (std::vector< aruco::Marker3DInfo > *)new std::vector< aruco::Marker3DInfo >(arg1,(std::vector< aruco::Marker3DInfo >::value_type const &)*arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMarker3DInfo(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_VectorMarker3DInfo__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorMarker3DInfo__SWIG_2(self, args); - } - } - if (argc == 1) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMarker3DInfo__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_size_t(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMarker3DInfo__SWIG_3(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorMarker3DInfo'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::vector()\n" - " std::vector< aruco::Marker3DInfo >::vector(std::vector< aruco::Marker3DInfo > const &)\n" - " std::vector< aruco::Marker3DInfo >::vector(std::vector< aruco::Marker3DInfo >::size_type)\n" - " std::vector< aruco::Marker3DInfo >::vector(std::vector< aruco::Marker3DInfo >::size_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::value_type *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_push_back",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_push_back" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMarker3DInfo_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_push_back" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg2 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp2); - (arg1)->push_back((std::vector< aruco::Marker3DInfo >::value_type const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_front",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_front" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (std::vector< aruco::Marker3DInfo >::value_type *) &((std::vector< aruco::Marker3DInfo > const *)arg1)->front(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::value_type *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_back",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_back" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = (std::vector< aruco::Marker3DInfo >::value_type *) &((std::vector< aruco::Marker3DInfo > const *)arg1)->back(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::size_type arg2 ; - std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_assign",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_assign" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_assign" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_assign" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); - (arg1)->assign(arg2,(std::vector< aruco::Marker3DInfo >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::size_type arg2 ; - std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_resize",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_resize" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_resize" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_resize" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); - (arg1)->resize(arg2,(std::vector< aruco::Marker3DInfo >::value_type const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_resize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorMarker3DInfo_resize__SWIG_0(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorMarker3DInfo_resize__SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo_resize'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::resize(std::vector< aruco::Marker3DInfo >::size_type)\n" - " std::vector< aruco::Marker3DInfo >::resize(std::vector< aruco::Marker3DInfo >::size_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::iterator arg2 ; - std::vector< aruco::Marker3DInfo >::value_type *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - std::vector< aruco::Marker3DInfo >::iterator result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:VectorMarker3DInfo_insert",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMarker3DInfo_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg3 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp3); - result = std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_0(arg1,arg2,(aruco::Marker3DInfo const &)*arg3); - resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< aruco::Marker3DInfo >::iterator & >(result)), - swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::iterator arg2 ; - std::vector< aruco::Marker3DInfo >::size_type arg3 ; - std::vector< aruco::Marker3DInfo >::value_type *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - swig::SwigPyIterator *iter2 = 0 ; - int res2 ; - size_t val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorMarker3DInfo_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_insert" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); - if (!SWIG_IsOK(res2) || !iter2) { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } else { - swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); - if (iter_t) { - arg2 = iter_t->get_current(); - } else { - SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorMarker3DInfo_insert" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::iterator""'"); - } - } - ecode3 = SWIG_AsVal_size_t(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorMarker3DInfo_insert" "', argument " "3"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); - } - arg3 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMarker3DInfo_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMarker3DInfo_insert" "', argument " "4"" of type '" "std::vector< aruco::Marker3DInfo >::value_type const &""'"); - } - arg4 = reinterpret_cast< std::vector< aruco::Marker3DInfo >::value_type * >(argp4); - std_vector_Sl_aruco_Marker3DInfo_Sg__insert__SWIG_1(arg1,arg2,arg3,(aruco::Marker3DInfo const &)*arg4); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_insert(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorMarker3DInfo_insert__SWIG_0(self, args); - } - } - } - } - if (argc == 4) { - int _v; - int res = swig::asptr(argv[0], (std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - swig::SwigPyIterator *iter = 0; - int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); - _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_aruco__Marker3DInfo, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorMarker3DInfo_insert__SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorMarker3DInfo_insert'.\n" - " Possible C/C++ prototypes are:\n" - " std::vector< aruco::Marker3DInfo >::insert(std::vector< aruco::Marker3DInfo >::iterator,std::vector< aruco::Marker3DInfo >::value_type const &)\n" - " std::vector< aruco::Marker3DInfo >::insert(std::vector< aruco::Marker3DInfo >::iterator,std::vector< aruco::Marker3DInfo >::size_type,std::vector< aruco::Marker3DInfo >::value_type const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - std::vector< aruco::Marker3DInfo >::size_type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:VectorMarker3DInfo_reserve",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_reserve" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorMarker3DInfo_reserve" "', argument " "2"" of type '" "std::vector< aruco::Marker3DInfo >::size_type""'"); - } - arg2 = static_cast< std::vector< aruco::Marker3DInfo >::size_type >(val2); - (arg1)->reserve(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorMarker3DInfo_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker3DInfo >::size_type result; - - if (!PyArg_ParseTuple(args,(char *)"O:VectorMarker3DInfo_capacity",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMarker3DInfo_capacity" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > const *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - result = ((std::vector< aruco::Marker3DInfo > const *)arg1)->capacity(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_VectorMarker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< aruco::Marker3DInfo > *arg1 = (std::vector< aruco::Marker3DInfo > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorMarker3DInfo",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorMarker3DInfo" "', argument " "1"" of type '" "std::vector< aruco::Marker3DInfo > *""'"); - } - arg1 = reinterpret_cast< std::vector< aruco::Marker3DInfo > * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorMarker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_Marker_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_id_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_id_set" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_id_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->id = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_id_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_id_get" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (int) ((arg1)->id); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_ssize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_ssize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_ssize_set" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_ssize_set" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - if (arg1) (arg1)->ssize = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_ssize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_ssize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_ssize_get" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (float) ((arg1)->ssize); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_Rvec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - cv::Mat arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_Rvec_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Rvec_set" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - if (arg1) (arg1)->Rvec = arg2; - resultobj = SWIG_Py_Void(); - { - - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_Rvec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_Rvec_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Rvec_get" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = ((arg1)->Rvec); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_Tvec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - cv::Mat arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_Tvec_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Tvec_set" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - if (arg1) (arg1)->Tvec = arg2; - resultobj = SWIG_Py_Void(); - { - - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_Tvec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_Tvec_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_Tvec_get" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = ((arg1)->Tvec); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_dict_info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_dict_info_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_dict_info_set" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_dict_info_set" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_dict_info_set" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = ptr; - } - if (arg1) (arg1)->dict_info = *arg2; - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_dict_info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_dict_info_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_dict_info_get" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (std::string *) & ((arg1)->dict_info); - resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_contourPoints_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - vector< cv::Point > arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_contourPoints_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_contourPoints_set" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_cv__Point_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_contourPoints_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_contourPoints_set" "', argument " "2"" of type '" "vector< cv::Point >""'"); - } else { - vector< cv::Point > * temp = reinterpret_cast< vector< cv::Point > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->contourPoints = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_contourPoints_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - vector< cv::Point > result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_contourPoints_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_contourPoints_get" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = ((arg1)->contourPoints); - resultobj = SWIG_NewPointerObj((new vector< cv::Point >(static_cast< const vector< cv::Point >& >(result))), SWIGTYPE_p_vectorT_cv__Point_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Marker")) SWIG_fail; - result = (aruco::Marker *)new aruco::Marker(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - aruco::Marker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_Marker",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Marker" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - result = (aruco::Marker *)new aruco::Marker(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::Marker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_Marker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Marker" "', argument " "1"" of type '" "aruco::Marker const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Marker" "', argument " "1"" of type '" "aruco::Marker const &""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (aruco::Marker *)new aruco::Marker((aruco::Marker const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg1 = 0 ; - int arg2 ; - int res1 = SWIG_OLDOBJ ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::Marker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_Marker",&obj0,&obj1)) SWIG_fail; - { - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; - res1 = swig::asptr(obj0, &ptr); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - arg1 = ptr; - } - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Marker" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (aruco::Marker *)new aruco::Marker((std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); - if (SWIG_IsNewObj(res1)) delete arg1; - return resultobj; -fail: - if (SWIG_IsNewObj(res1)) delete arg1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg1 = 0 ; - int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - aruco::Marker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_Marker",&obj0)) SWIG_fail; - { - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *ptr = (std::vector< cv::Point2f,std::allocator< cv::Point2f > > *)0; - res1 = swig::asptr(obj0, &ptr); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Marker" "', argument " "1"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &""'"); - } - arg1 = ptr; - } - result = (aruco::Marker *)new aruco::Marker((std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)*arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker, SWIG_POINTER_NEW | 0 ); - if (SWIG_IsNewObj(res1)) delete arg1; - return resultobj; -fail: - if (SWIG_IsNewObj(res1)) delete arg1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_Marker__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Marker__SWIG_2(self, args); - } - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Marker__SWIG_1(self, args); - } - } - if (argc == 1) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Marker__SWIG_4(self, args); - } - } - if (argc == 2) { - int _v; - int res = swig::asptr(argv[0], (std::vector< cv::Point2f,std::allocator< cv::Point2f > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Marker__SWIG_3(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Marker'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Marker::Marker()\n" - " aruco::Marker::Marker(int)\n" - " aruco::Marker::Marker(aruco::Marker const &)\n" - " aruco::Marker::Marker(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &,int)\n" - " aruco::Marker::Marker(std::vector< cv::Point2f,std::allocator< cv::Point2f > > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_Marker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_Marker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Marker" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_isValid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_isValid" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (bool)((aruco::Marker const *)arg1)->isValid(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_isPoseValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_isPoseValid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_isPoseValid" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (bool)((aruco::Marker const *)arg1)->isPoseValid(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - cv::Mat *arg2 = 0 ; - cv::Scalar arg3 ; - int arg4 ; - bool arg5 ; - bool arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - bool val6 ; - int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Marker_draw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - { - arg3 = *array_to_scalar(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_draw" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Marker_draw" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_bool(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Marker_draw" "', argument " "6"" of type '" "bool""'"); - } - arg6 = static_cast< bool >(val6); - ((aruco::Marker const *)arg1)->draw(*arg2,arg3,arg4,arg5,arg6); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - cv::Mat *arg2 = 0 ; - cv::Scalar arg3 ; - int arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Marker_draw",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - { - arg3 = *array_to_scalar(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_draw" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Marker_draw" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ((aruco::Marker const *)arg1)->draw(*arg2,arg3,arg4,arg5); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - cv::Mat *arg2 = 0 ; - cv::Scalar arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - int val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:Marker_draw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - { - arg3 = *array_to_scalar(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_draw" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - ((aruco::Marker const *)arg1)->draw(*arg2,arg3,arg4); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - cv::Mat *arg2 = 0 ; - cv::Scalar arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_draw",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - { - arg3 = *array_to_scalar(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - ((aruco::Marker const *)arg1)->draw(*arg2,arg3); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_draw__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - cv::Mat *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_draw",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_draw" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - ((aruco::Marker const *)arg1)->draw(*arg2); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_draw(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - return _wrap_Marker_draw__SWIG_4(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - return _wrap_Marker_draw__SWIG_3(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Marker_draw__SWIG_2(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Marker_draw__SWIG_1(self, args); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Marker_draw__SWIG_0(self, args); - } - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_draw'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Marker::draw(cv::Mat &,cv::Scalar,int,bool,bool) const\n" - " aruco::Marker::draw(cv::Mat &,cv::Scalar,int,bool) const\n" - " aruco::Marker::draw(cv::Mat &,cv::Scalar,int) const\n" - " aruco::Marker::draw(cv::Mat &,cv::Scalar) const\n" - " aruco::Marker::draw(cv::Mat &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - float arg2 ; - aruco::CameraParameters *arg3 = 0 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Marker_calculateExtrinsics" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - (arg1)->calculateExtrinsics(arg2,(aruco::CameraParameters const &)*arg3,arg4); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - float arg2 ; - aruco::CameraParameters *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_calculateExtrinsics" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - (arg1)->calculateExtrinsics(arg2,(aruco::CameraParameters const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - float arg2 ; - cv::Mat arg3 ; - cv::Mat arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - cv::Mat *mat3 ; - cv::Mat *mat4 ; - bool val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - { - mat3 = array_to_mat(obj2); - if (mat3 == NULL) - SWIG_fail; - arg3 = *mat3; - } - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; - } - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Marker_calculateExtrinsics" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - (arg1)->calculateExtrinsics(arg2,arg3,arg4,arg5); - resultobj = SWIG_Py_Void(); - { - - } - { - - } - { - if (mat3 != NULL) - delete mat3; - } - { - if (mat4 != NULL) - delete mat4; - } - return resultobj; -fail: - { - if (mat3 != NULL) - delete mat3; - } - { - if (mat4 != NULL) - delete mat4; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - float arg2 ; - cv::Mat arg3 ; - cv::Mat arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - cv::Mat *mat3 ; - cv::Mat *mat4 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - { - mat3 = array_to_mat(obj2); - if (mat3 == NULL) - SWIG_fail; - arg3 = *mat3; - } - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; - } - (arg1)->calculateExtrinsics(arg2,arg3,arg4); - resultobj = SWIG_Py_Void(); - { - - } - { - - } - { - if (mat3 != NULL) - delete mat3; - } - { - if (mat4 != NULL) - delete mat4; - } - return resultobj; -fail: - { - if (mat3 != NULL) - delete mat3; - } - { - if (mat4 != NULL) - delete mat4; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - float arg2 ; - cv::Mat arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - cv::Mat *mat3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_calculateExtrinsics",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_calculateExtrinsics" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker_calculateExtrinsics" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - { - mat3 = array_to_mat(obj2); - if (mat3 == NULL) - SWIG_fail; - arg3 = *mat3; - } - (arg1)->calculateExtrinsics(arg2,arg3); - resultobj = SWIG_Py_Void(); - { - - } - { - if (mat3 != NULL) - delete mat3; - } - return resultobj; -fail: - { - if (mat3 != NULL) - delete mat3; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_calculateExtrinsics(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Marker_calculateExtrinsics__SWIG_1(self, args); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - return _wrap_Marker_calculateExtrinsics__SWIG_4(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - { - _v = is_array(argv[3]) || PySequence_Check(argv[3]); - } - if (_v) { - return _wrap_Marker_calculateExtrinsics__SWIG_3(self, args); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Marker_calculateExtrinsics__SWIG_0(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = is_array(argv[2]) || PySequence_Check(argv[2]); - } - if (_v) { - { - _v = is_array(argv[3]) || PySequence_Check(argv[3]); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Marker_calculateExtrinsics__SWIG_2(self, args); - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_calculateExtrinsics'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Marker::calculateExtrinsics(float,aruco::CameraParameters const &,bool)\n" - " aruco::Marker::calculateExtrinsics(float,aruco::CameraParameters const &)\n" - " aruco::Marker::calculateExtrinsics(float,cv::Mat,cv::Mat,bool)\n" - " aruco::Marker::calculateExtrinsics(float,cv::Mat,cv::Mat)\n" - " aruco::Marker::calculateExtrinsics(float,cv::Mat)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Marker_glGetModelViewMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - double *arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_glGetModelViewMatrix",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_glGetModelViewMatrix" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_glGetModelViewMatrix" "', argument " "2"" of type '" "double [16]""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - (arg1)->glGetModelViewMatrix(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_OgreGetPoseParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - double *arg2 ; - double *arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:Marker_OgreGetPoseParameters",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_OgreGetPoseParameters" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_OgreGetPoseParameters" "', argument " "2"" of type '" "double [3]""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Marker_OgreGetPoseParameters" "', argument " "3"" of type '" "double [4]""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - (arg1)->OgreGetPoseParameters(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Point2f result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_getCenter",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getCenter" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = ((aruco::Marker const *)arg1)->getCenter(); - { - PyObject* array = point2f_to_array(&result); - if (array == NULL) - SWIG_fail; - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_getPerimeter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_getPerimeter",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getPerimeter" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (float)((aruco::Marker const *)arg1)->getPerimeter(); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_getArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_getArea",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getArea" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (float)((aruco::Marker const *)arg1)->getArea(); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_getRadius(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_getRadius",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getRadius" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = (float)((aruco::Marker const *)arg1)->getRadius(); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - aruco::Marker *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker___eq__" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker___eq__" "', argument " "2"" of type '" "aruco::Marker const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker___eq__" "', argument " "2"" of type '" "aruco::Marker const &""'"); - } - arg2 = reinterpret_cast< aruco::Marker * >(argp2); - result = (bool)((aruco::Marker const *)arg1)->operator ==((aruco::Marker const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_copyTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - aruco::Marker *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_copyTo",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_copyTo" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_copyTo" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_copyTo" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - arg2 = reinterpret_cast< aruco::Marker * >(argp2); - ((aruco::Marker const *)arg1)->copyTo(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_toStream" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - ((aruco::Marker const *)arg1)->toStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker_fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_fromStream" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - (arg1)->fromStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_get3DPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - float arg1 ; - float val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - vector< cv::Point3f > result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_get3DPoints",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_float(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Marker_get3DPoints" "', argument " "1"" of type '" "float""'"); - } - arg1 = static_cast< float >(val1); - result = aruco::Marker::get3DPoints(arg1); - resultobj = SWIG_NewPointerObj((new vector< cv::Point3f >(static_cast< const vector< cv::Point3f >& >(result))), SWIGTYPE_p_vectorT_cv__Point3f_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_get3DPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - vector< cv::Point3f > result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_get3DPoints",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_get3DPoints" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = ((aruco::Marker const *)arg1)->get3DPoints(); - resultobj = SWIG_NewPointerObj((new vector< cv::Point3f >(static_cast< const vector< cv::Point3f >& >(result))), SWIGTYPE_p_vectorT_cv__Point3f_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker_get3DPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Marker_get3DPoints__SWIG_1(self, args); - } - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_float(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Marker_get3DPoints__SWIG_0(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Marker_get3DPoints'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Marker::get3DPoints(float)\n" - " aruco::Marker::get3DPoints() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Marker_getTransformMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker_getTransformMatrix",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker_getTransformMatrix" "', argument " "1"" of type '" "aruco::Marker const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - result = ((aruco::Marker const *)arg1)->getTransformMatrix(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker *arg1 = (aruco::Marker *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Point2f result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker___getitem__" "', argument " "1"" of type '" "aruco::Marker *""'"); - } - arg1 = reinterpret_cast< aruco::Marker * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker___getitem__" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = aruco_Marker___getitem__(arg1,arg2); - { - PyObject* array = point2f_to_array(&result); - if (array == NULL) - SWIG_fail; - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Marker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_MarkerDetector")) SWIG_fail; - result = (aruco::MarkerDetector *)new aruco::MarkerDetector(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - float arg2 ; - int val1 ; - int ecode1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::MarkerDetector *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_MarkerDetector",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkerDetector" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - aruco::MarkerDetector *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerDetector",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - float arg2 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::MarkerDetector *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_MarkerDetector",&obj0,&obj1)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkerDetector" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerDetector__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::MarkerDetector *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerDetector",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerDetector" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::MarkerDetector *)new aruco::MarkerDetector(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerDetector(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_MarkerDetector__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MarkerDetector__SWIG_2(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MarkerDetector__SWIG_4(self, args); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MarkerDetector__SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MarkerDetector__SWIG_3(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerDetector'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::MarkerDetector()\n" - " aruco::MarkerDetector::MarkerDetector(int,float)\n" - " aruco::MarkerDetector::MarkerDetector(int)\n" - " aruco::MarkerDetector::MarkerDetector(std::string,float)\n" - " aruco::MarkerDetector::MarkerDetector(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_saveParamsToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_saveParamsToFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_saveParamsToFile" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_saveParamsToFile" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_saveParamsToFile" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = ptr; - } - ((aruco::MarkerDetector const *)arg1)->saveParamsToFile((std::string const &)*arg2); - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_loadParamsFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_loadParamsFromFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_loadParamsFromFile" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_loadParamsFromFile" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_loadParamsFromFile" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = ptr; - } - (arg1)->loadParamsFromFile((std::string const &)*arg2); - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MarkerDetector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerDetector",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerDetector" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDetectionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - aruco::DetectionMode arg2 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDetectionMode",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDetectionMode" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDetectionMode" "', argument " "2"" of type '" "aruco::DetectionMode""'"); - } - arg2 = static_cast< aruco::DetectionMode >(val2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDetectionMode" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setDetectionMode(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDetectionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - aruco::DetectionMode arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDetectionMode",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDetectionMode" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDetectionMode" "', argument " "2"" of type '" "aruco::DetectionMode""'"); - } - arg2 = static_cast< aruco::DetectionMode >(val2); - (arg1)->setDetectionMode(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDetectionMode(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_setDetectionMode__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_setDetectionMode__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_setDetectionMode'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::setDetectionMode(aruco::DetectionMode,float)\n" - " aruco::MarkerDetector::setDetectionMode(aruco::DetectionMode)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getDetectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::DetectionMode result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getDetectionMode",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getDetectionMode" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (aruco::DetectionMode)(arg1)->getDetectionMode(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_detect",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - result = (arg1)->detect((cv::Mat const &)*arg2); - resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - float arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "float""'"); - } - arg4 = static_cast< float >(val4); - ecode5 = SWIG_AsVal_bool(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerDetector_detect" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - result = (arg1)->detect((cv::Mat const &)*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); - resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_detect__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Mat *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - float arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerDetector_detect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_detect" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_detect" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerDetector_detect" "', argument " "4"" of type '" "float""'"); - } - arg4 = static_cast< float >(val4); - result = (arg1)->detect((cv::Mat const &)*arg2,(aruco::CameraParameters const &)*arg3,arg4); - resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_detect(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_0(self, args); - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_2(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_detect__SWIG_1(self, args); - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_detect'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::detect(cv::Mat const &)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float,bool)\n" - " aruco::MarkerDetector::detect(cv::Mat const &,aruco::CameraParameters const &,float)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::MarkerDetector::Params result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = ((aruco::MarkerDetector const *)arg1)->getParameters(); - resultobj = SWIG_NewPointerObj((new aruco::MarkerDetector::Params(static_cast< const aruco::MarkerDetector::Params& >(result))), SWIGTYPE_p_aruco__MarkerDetector__Params, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::MarkerDetector::Params *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (aruco::MarkerDetector::Params *) &(arg1)->getParameters(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getParameters(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getParameters__SWIG_0(self, args); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getParameters__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getParameters'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::getParameters() const\n" - " aruco::MarkerDetector::getParameters()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::string arg2 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setDictionary(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->setDictionary(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - int arg2 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_setDictionary",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerDetector_setDictionary" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setDictionary(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setDictionary",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setDictionary" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerDetector_setDictionary" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - (arg1)->setDictionary(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setDictionary(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_3(self, args); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_2(self, args); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerDetector_setDictionary__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_setDictionary'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::setDictionary(std::string,float)\n" - " aruco::MarkerDetector::setDictionary(std::string)\n" - " aruco::MarkerDetector::setDictionary(int,float)\n" - " aruco::MarkerDetector::setDictionary(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - uint32_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_getThresholdedImage",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint32_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_getThresholdedImage" "', argument " "2"" of type '" "uint32_t""'"); - } else { - uint32_t * temp = reinterpret_cast< uint32_t * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - result = (arg1)->getThresholdedImage(arg2); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getThresholdedImage",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getThresholdedImage" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (arg1)->getThresholdedImage(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getThresholdedImage(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getThresholdedImage__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_uint32_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerDetector_getThresholdedImage__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerDetector_getThresholdedImage'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerDetector::getThresholdedImage(uint32_t)\n" - " aruco::MarkerDetector::getThresholdedImage()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - cv::Ptr< aruco::MarkerLabeler > arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setMarkerLabeler",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setMarkerLabeler" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerLabeler >""'"); - } else { - cv::Ptr< aruco::MarkerLabeler > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerLabeler > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - (arg1)->setMarkerLabeler(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getMarkerLabeler",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getMarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (arg1)->getMarkerLabeler(); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::MarkerCandidate,std::allocator< aruco::MarkerCandidate > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getCandidates",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getCandidates" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = ((aruco::MarkerDetector const *)arg1)->getCandidates(); - resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_getImagePyramid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - SwigValueWrapper< std::vector< cv::Mat,std::allocator< cv::Mat > > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerDetector_getImagePyramid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_getImagePyramid" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - result = (arg1)->getImagePyramid(); - resultobj = SWIG_NewPointerObj((new std::vector< cv::Mat,std::allocator< cv::Mat > >(static_cast< const std::vector< cv::Mat,std::allocator< cv::Mat > >& >(result))), SWIGTYPE_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_cornerUpsample(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > *arg2 = 0 ; - cv::Size arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerDetector_cornerUpsample",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_cornerUpsample" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_cornerUpsample" "', argument " "2"" of type '" "std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_cornerUpsample" "', argument " "2"" of type '" "std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > &""'"); - } - arg2 = reinterpret_cast< std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > * >(argp2); - { - arg3 = *array_to_size(obj2); - if (&arg3 == NULL) - SWIG_fail; - } - (arg1)->cornerUpsample(*arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_toStream" "', argument " "1"" of type '" "aruco::MarkerDetector const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - ((aruco::MarkerDetector const *)arg1)->toStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_fromStream" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - (arg1)->fromStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerDetector_setParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerDetector *arg1 = (aruco::MarkerDetector *) 0 ; - aruco::MarkerDetector::Params *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerDetector_setParameters",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerDetector_setParameters" "', argument " "1"" of type '" "aruco::MarkerDetector *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__MarkerDetector__Params, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerDetector_setParameters" "', argument " "2"" of type '" "aruco::MarkerDetector::Params const &""'"); - } - arg2 = reinterpret_cast< aruco::MarkerDetector::Params * >(argp2); - (arg1)->setParameters((aruco::MarkerDetector::Params const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MarkerDetector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerDetector, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary::DICT_TYPES arg1 ; - float arg2 ; - int val1 ; - int ecode1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); - } - arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = aruco::MarkerLabeler::create(arg1,arg2); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Dictionary::DICT_TYPES arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "aruco::Dictionary::DICT_TYPES""'"); - } - arg1 = static_cast< aruco::Dictionary::DICT_TYPES >(val1); - result = aruco::MarkerLabeler::create(arg1); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - std::string arg2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerLabeler_create",&obj0,&obj1)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::MarkerLabeler::create(arg1,arg2); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_create__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - cv::Ptr< aruco::MarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_create",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::MarkerLabeler::create(arg1); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::MarkerLabeler >(static_cast< const cv::Ptr< aruco::MarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__MarkerLabeler_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_create(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerLabeler_create__SWIG_1(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerLabeler_create__SWIG_3(self, args); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerLabeler_create__SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerLabeler_create__SWIG_2(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerLabeler_create'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES,float)\n" - " aruco::MarkerLabeler::create(aruco::Dictionary::DICT_TYPES)\n" - " aruco::MarkerLabeler::create(std::string,std::string)\n" - " aruco::MarkerLabeler::create(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - cv::Mat *arg2 = 0 ; - int *arg3 = 0 ; - int *arg4 = 0 ; - std::string *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerLabeler_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_detect" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); - } - arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); - } - arg5 = reinterpret_cast< std::string * >(argp5); - result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_getBestInputSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getBestInputSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getBestInputSize" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - result = (int)(arg1)->getBestInputSize(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getNSubdivisions",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getNSubdivisions" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - result = (int)((aruco::MarkerLabeler const *)arg1)->getNSubdivisions(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerLabeler_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerLabeler_getName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerLabeler_getName" "', argument " "1"" of type '" "aruco::MarkerLabeler const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - result = ((aruco::MarkerLabeler const *)arg1)->getName(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerLabeler *arg1 = (aruco::MarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerLabeler",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerLabeler, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerLabeler" "', argument " "1"" of type '" "aruco::MarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerLabeler * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MarkerLabeler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerLabeler, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_FractalDetector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_FractalDetector")) SWIG_fail; - result = (aruco::FractalDetector *)new aruco::FractalDetector(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalDetector, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_setConfiguration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_setConfiguration",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_setConfiguration" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalDetector_setConfiguration" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - (arg1)->setConfiguration(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_setConfiguration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_setConfiguration",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_setConfiguration" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalDetector_setConfiguration" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->setConfiguration(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_setConfiguration(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalDetector_setConfiguration__SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalDetector_setConfiguration__SWIG_1(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalDetector_setConfiguration'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalDetector::setConfiguration(int)\n" - " aruco::FractalDetector::setConfiguration(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - aruco::CameraParameters *arg2 = 0 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalDetector_setParams",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_setParams" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalDetector_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalDetector_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalDetector_setParams" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setParams((aruco::CameraParameters const &)*arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_getConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getConfiguration",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getConfiguration" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - result = (arg1)->getConfiguration(); - resultobj = SWIG_NewPointerObj((new FractalMarkerSet(static_cast< const FractalMarkerSet& >(result))), SWIGTYPE_p_FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - cv::Mat *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_detect",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_detect" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - result = (bool)(arg1)->detect((cv::Mat const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_poseEstimation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_poseEstimation",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_poseEstimation" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - result = (bool)(arg1)->poseEstimation(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getRvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getRvec" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - result = (arg1)->getRvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getTvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getTvec" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - result = (arg1)->getTvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_drawMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - cv::Mat *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_drawMarkers",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_drawMarkers" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - (arg1)->drawMarkers(*arg2); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_draw2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - cv::Mat *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_draw2d",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw2d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - (arg1)->draw2d(*arg2); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_draw3d__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - cv::Mat *arg2 = 0 ; - bool arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - bool val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalDetector_draw3d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - ecode3 = SWIG_AsVal_bool(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalDetector_draw3d" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalDetector_draw3d" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - (arg1)->draw3d(*arg2,arg3,arg4); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_draw3d__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - cv::Mat *arg2 = 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - bool val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalDetector_draw3d",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - ecode3 = SWIG_AsVal_bool(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalDetector_draw3d" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - (arg1)->draw3d(*arg2,arg3); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_draw3d__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - cv::Mat *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalDetector_draw3d",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3d" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - (arg1)->draw3d(*arg2); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_draw3d(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - return _wrap_FractalDetector_draw3d__SWIG_2(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalDetector_draw3d__SWIG_1(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalDetector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalDetector_draw3d__SWIG_0(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalDetector_draw3d'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalDetector::draw3d(cv::Mat &,bool,bool)\n" - " aruco::FractalDetector::draw3d(cv::Mat &,bool)\n" - " aruco::FractalDetector::draw3d(cv::Mat &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_draw3dCube(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - cv::Mat *arg2 = 0 ; - FractalMarker arg3 ; - aruco::CameraParameters *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - void *argp3 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalDetector_draw3dCube",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_draw3dCube" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FractalMarker, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalDetector_draw3dCube" "', argument " "3"" of type '" "FractalMarker""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalDetector_draw3dCube" "', argument " "3"" of type '" "FractalMarker""'"); - } else { - FractalMarker * temp = reinterpret_cast< FractalMarker * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalDetector_draw3dCube" "', argument " "4"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalDetector_draw3dCube" "', argument " "4"" of type '" "aruco::CameraParameters const &""'"); - } - arg4 = reinterpret_cast< aruco::CameraParameters * >(argp4); - ecode5 = SWIG_AsVal_int(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FractalDetector_draw3dCube" "', argument " "5"" of type '" "int""'"); - } - arg5 = static_cast< int >(val5); - (arg1)->draw3dCube(*arg2,arg3,(aruco::CameraParameters const &)*arg4,arg5); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalDetector_getMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalDetector_getMarkers",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalDetector_getMarkers" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - result = (arg1)->getMarkers(); - resultobj = swig::from(static_cast< std::vector< aruco::Marker,std::allocator< aruco::Marker > > >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FractalDetector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalDetector *arg1 = (aruco::FractalDetector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalDetector",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalDetector, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalDetector" "', argument " "1"" of type '" "aruco::FractalDetector *""'"); - } - arg1 = reinterpret_cast< aruco::FractalDetector * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *FractalDetector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalDetector, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_Marker3DInfo_points_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - std::vector< cv::Point3f,std::allocator< cv::Point3f > > *arg2 = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_points_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_points_set" "', argument " "2"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > > *""'"); - } - arg2 = reinterpret_cast< std::vector< cv::Point3f,std::allocator< cv::Point3f > > * >(argp2); - if (arg1) (arg1)->points = *arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_points_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< cv::Point3f,std::allocator< cv::Point3f > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_points_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_points_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = (std::vector< cv::Point3f,std::allocator< cv::Point3f > > *)& ((arg1)->points); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_id_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_set" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_id_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->id = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_id_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_id_get" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = (int) ((arg1)->id); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Marker3DInfo")) SWIG_fail; - result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker3DInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - aruco::Marker3DInfo *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_Marker3DInfo",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Marker3DInfo" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - result = (aruco::Marker3DInfo *)new aruco::Marker3DInfo(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Marker3DInfo(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_Marker3DInfo__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Marker3DInfo__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Marker3DInfo'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Marker3DInfo::Marker3DInfo()\n" - " aruco::Marker3DInfo::Marker3DInfo(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - aruco::Marker3DInfo *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo___eq__" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo___eq__" "', argument " "2"" of type '" "aruco::Marker3DInfo const &""'"); - } - arg2 = reinterpret_cast< aruco::Marker3DInfo * >(argp2); - result = (bool)(arg1)->operator ==((aruco::Marker3DInfo const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_getMarkerSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_getMarkerSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_getMarkerSize" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = (float)((aruco::Marker3DInfo const *)arg1)->getMarkerSize(); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - size_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Point3f result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_at",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_at" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Marker3DInfo_at" "', argument " "2"" of type '" "size_t""'"); - } - arg2 = static_cast< size_t >(val2); - result = ((aruco::Marker3DInfo const *)arg1)->at(arg2); - { - PyObject* array = point3f_to_array(&result); - if (array == NULL) - SWIG_fail; - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - cv::Point3f *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_push_back",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_push_back" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point3f, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_push_back" "', argument " "2"" of type '" "cv::Point3f const &""'"); - } - arg2 = reinterpret_cast< cv::Point3f * >(argp2); - (arg1)->push_back((cv::Point3f const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - size_t result; - - if (!PyArg_ParseTuple(args,(char *)"O:Marker3DInfo_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_size" "', argument " "1"" of type '" "aruco::Marker3DInfo const *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - result = ((aruco::Marker3DInfo const *)arg1)->size(); - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_toStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - (arg1)->toStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Marker3DInfo_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Marker3DInfo_fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Marker3DInfo_fromStream" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Marker3DInfo_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - (arg1)->fromStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_Marker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Marker3DInfo *arg1 = (aruco::Marker3DInfo *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_Marker3DInfo",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Marker3DInfo, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Marker3DInfo" "', argument " "1"" of type '" "aruco::Marker3DInfo *""'"); - } - arg1 = reinterpret_cast< aruco::Marker3DInfo * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Marker3DInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Marker3DInfo, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_MarkerMap")) SWIG_fail; - result = (aruco::MarkerMap *)new aruco::MarkerMap(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::MarkerMap *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_MarkerMap",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MarkerMap" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::MarkerMap *)new aruco::MarkerMap(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerMap(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_MarkerMap__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MarkerMap__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarkerMap'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerMap::MarkerMap()\n" - " aruco::MarkerMap::MarkerMap(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInMeters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInMeters(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_isExpressedInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_isExpressedInPixels",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_isExpressedInPixels" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = (bool)((aruco::MarkerMap const *)arg1)->isExpressedInPixels(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_convertToMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::MarkerMap result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_convertToMeters",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_convertToMeters" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_convertToMeters" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = ((aruco::MarkerMap const *)arg1)->convertToMeters(arg2); - resultobj = SWIG_NewPointerObj((new aruco::MarkerMap(static_cast< const aruco::MarkerMap& >(result))), SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - vector< aruco::Marker > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - std::vector< int,std::allocator< int > > result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndices",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndices" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_aruco__Marker_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIndices" "', argument " "2"" of type '" "vector< aruco::Marker > const &""'"); - } - arg2 = reinterpret_cast< vector< aruco::Marker > * >(argp2); - result = ((aruco::MarkerMap const *)arg1)->getIndices((vector< aruco::Marker > const &)*arg2); - resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getMarker3DInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::Marker3DInfo *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getMarker3DInfo",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getMarker3DInfo" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (aruco::Marker3DInfo *) &((aruco::MarkerMap const *)arg1)->getMarker3DInfo(arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Marker3DInfo, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getIndexOfMarkerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIndexOfMarkerId",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getIndexOfMarkerId" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (int)((aruco::MarkerMap const *)arg1)->getIndexOfMarkerId(arg2); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - vector< int > *arg2 = 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMap_getIdList",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); - } - arg2 = reinterpret_cast< vector< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_getIdList" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ((aruco::MarkerMap const *)arg1)->getIdList(*arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getIdList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - vector< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getIdList",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getIdList" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vectorT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_getIdList" "', argument " "2"" of type '" "vector< int > &""'"); - } - arg2 = reinterpret_cast< vector< int > * >(argp2); - ((aruco::MarkerMap const *)arg1)->getIdList(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getIdList(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerMap_getIdList__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vectorT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerMap_getIdList__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getIdList'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerMap::getIdList(vector< int > &,bool) const\n" - " aruco::MarkerMap::getIdList(vector< int > &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_getImage",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_getImage" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = ((aruco::MarkerMap const *)arg1)->getImage(arg2); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getImage",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getImage" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = ((aruco::MarkerMap const *)arg1)->getImage(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getImage(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerMap_getImage__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerMap_getImage__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMap_getImage'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerMap::getImage(float) const\n" - " aruco::MarkerMap::getImage() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_saveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_saveToFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_saveToFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_saveToFile" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->saveToFile(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_readFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_readFromFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_readFromFile" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_readFromFile" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->readFromFile(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_calculateExtrinsics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; - float arg3 ; - cv::Mat arg4 ; - cv::Mat arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - float val3 ; - int ecode3 = 0 ; - cv::Mat *mat4 ; - cv::Mat *mat5 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - std::pair< cv::Mat,cv::Mat > result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerMap_calculateExtrinsics",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res2 = swig::asptr(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_calculateExtrinsics" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg2 = ptr; - } - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMap_calculateExtrinsics" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - { - mat4 = array_to_mat(obj3); - if (mat4 == NULL) - SWIG_fail; - arg4 = *mat4; - } - { - mat5 = array_to_mat(obj4); - if (mat5 == NULL) - SWIG_fail; - arg5 = *mat5; - } - result = (arg1)->calculateExtrinsics((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2,arg3,arg4,arg5); - resultobj = SWIG_NewPointerObj((new std::pair< cv::Mat,cv::Mat >(static_cast< const std::pair< cv::Mat,cv::Mat >& >(result))), SWIGTYPE_p_std__pairT_cv__Mat_cv__Mat_t, SWIG_POINTER_OWN | 0 ); - { - - } - { - - } - if (SWIG_IsNewObj(res2)) delete arg2; - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - { - if (mat4 != NULL) - delete mat4; - } - { - if (mat5 != NULL) - delete mat5; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_getDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_getDictionary",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_getDictionary" "', argument " "1"" of type '" "aruco::MarkerMap const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = ((aruco::MarkerMap const *)arg1)->getDictionary(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_setDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_setDictionary",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_setDictionary" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MarkerMap_setDictionary" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->setDictionary(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_mInfoType_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_set" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMap_mInfoType_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->mInfoType = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_mInfoType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMap_mInfoType_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_mInfoType_get" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - result = (int) ((arg1)->mInfoType); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_toStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - (arg1)->toStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMap_fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMap_fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMap_fromStream" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMap_fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - (arg1)->fromStream(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MarkerMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMap *arg1 = (aruco::MarkerMap *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMap",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMap, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMap" "', argument " "1"" of type '" "aruco::MarkerMap *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMap * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MarkerMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMap, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - aruco::Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - float arg4 ; - float arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; - float val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - arg2 = reinterpret_cast< aruco::Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); - } - arg4 = static_cast< float >(val4); - ecode5 = SWIG_AsVal_float(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "5"" of type '" "float""'"); - } - arg5 = static_cast< float >(val5); - result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4,arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - aruco::Marker *arg2 = 0 ; - aruco::CameraParameters *arg3 = 0 ; - float arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerPoseTracker_estimatePose",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__Marker, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "2"" of type '" "aruco::Marker &""'"); - } - arg2 = reinterpret_cast< aruco::Marker * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerPoseTracker_estimatePose" "', argument " "3"" of type '" "aruco::CameraParameters const &""'"); - } - arg3 = reinterpret_cast< aruco::CameraParameters * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerPoseTracker_estimatePose" "', argument " "4"" of type '" "float""'"); - } - arg4 = static_cast< float >(val4); - result = (bool)(arg1)->estimatePose(*arg2,(aruco::CameraParameters const &)*arg3,arg4); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_estimatePose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerPoseTracker_estimatePose__SWIG_1(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_aruco__Marker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerPoseTracker_estimatePose__SWIG_0(self, args); - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerPoseTracker_estimatePose'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float,float)\n" - " aruco::MarkerPoseTracker::estimatePose(aruco::Marker &,aruco::CameraParameters const &,float)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRTMatrix",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - result = ((aruco::MarkerPoseTracker const *)arg1)->getRTMatrix(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getRvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - result = ((aruco::MarkerPoseTracker const *)arg1)->getRvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerPoseTracker_getTvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - result = ((aruco::MarkerPoseTracker const *)arg1)->getTvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerPoseTracker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_MarkerPoseTracker")) SWIG_fail; - result = (aruco::MarkerPoseTracker *)new aruco::MarkerPoseTracker(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MarkerPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerPoseTracker *arg1 = (aruco::MarkerPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerPoseTracker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerPoseTracker" "', argument " "1"" of type '" "aruco::MarkerPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerPoseTracker * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MarkerPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerPoseTracker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_MarkerMapPoseTracker")) SWIG_fail; - result = (aruco::MarkerMapPoseTracker *)new aruco::MarkerMapPoseTracker(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - aruco::CameraParameters *arg2 = 0 ; - aruco::MarkerMap *arg3 = 0 ; - float arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - float val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); - } - arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); - ecode4 = SWIG_AsVal_float(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "4"" of type '" "float""'"); - } - arg4 = static_cast< float >(val4); - (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3,arg4); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - aruco::CameraParameters *arg2 = 0 ; - aruco::MarkerMap *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setParams",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_aruco__MarkerMap, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_setParams" "', argument " "3"" of type '" "aruco::MarkerMap const &""'"); - } - arg3 = reinterpret_cast< aruco::MarkerMap * >(argp3); - (arg1)->setParams((aruco::CameraParameters const &)*arg2,(aruco::MarkerMap const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setParams(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MarkerMapPoseTracker_setParams__SWIG_1(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_aruco__CameraParameters, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_aruco__MarkerMap, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MarkerMapPoseTracker_setParams__SWIG_0(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MarkerMapPoseTracker_setParams'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &,float)\n" - " aruco::MarkerMapPoseTracker::setParams(aruco::CameraParameters const &,aruco::MarkerMap const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_isValid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_isValid" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = (bool)((aruco::MarkerMapPoseTracker const *)arg1)->isValid(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_reset",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_reset" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - (arg1)->reset(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_estimatePose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:MarkerMapPoseTracker_estimatePose",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res2 = swig::asptr(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkerMapPoseTracker_estimatePose" "', argument " "2"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg2 = ptr; - } - result = (bool)(arg1)->estimatePose((std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRTMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRTMatrix",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRTMatrix" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRTMatrix(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getRvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = ((aruco::MarkerMapPoseTracker const *)arg1)->getRvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:MarkerMapPoseTracker_getTvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - result = ((aruco::MarkerMapPoseTracker const *)arg1)->getTvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MarkerMapPoseTracker_setMaxTrackingDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - float arg2 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:MarkerMapPoseTracker_setMaxTrackingDifference",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarkerMapPoseTracker_setMaxTrackingDifference" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->setMaxTrackingDifference(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MarkerMapPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::MarkerMapPoseTracker *arg1 = (aruco::MarkerMapPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_MarkerMapPoseTracker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkerMapPoseTracker" "', argument " "1"" of type '" "aruco::MarkerMapPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::MarkerMapPoseTracker * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MarkerMapPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__MarkerMapPoseTracker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_PicoFlann_KeyPointAdapter___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::PicoFlann_KeyPointAdapter *arg1 = (aruco::PicoFlann_KeyPointAdapter *) 0 ; - cv::KeyPoint *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:PicoFlann_KeyPointAdapter___call__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "1"" of type '" "aruco::PicoFlann_KeyPointAdapter const *""'"); - } - arg1 = reinterpret_cast< aruco::PicoFlann_KeyPointAdapter * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__KeyPoint, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::KeyPoint const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::KeyPoint const &""'"); - } - arg2 = reinterpret_cast< cv::KeyPoint * >(argp2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - result = (float)((aruco::PicoFlann_KeyPointAdapter const *)arg1)->operator ()((cv::KeyPoint const &)*arg2,arg3); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PicoFlann_KeyPointAdapter___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::PicoFlann_KeyPointAdapter *arg1 = (aruco::PicoFlann_KeyPointAdapter *) 0 ; - cv::Point2f *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:PicoFlann_KeyPointAdapter___call__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "1"" of type '" "aruco::PicoFlann_KeyPointAdapter const *""'"); - } - arg1 = reinterpret_cast< aruco::PicoFlann_KeyPointAdapter * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Point2f, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::Point2f const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "2"" of type '" "cv::Point2f const &""'"); - } - arg2 = reinterpret_cast< cv::Point2f * >(argp2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PicoFlann_KeyPointAdapter___call__" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - result = (float)((aruco::PicoFlann_KeyPointAdapter const *)arg1)->operator ()((cv::Point2f const &)*arg2,arg3); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PicoFlann_KeyPointAdapter___call__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__KeyPoint, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PicoFlann_KeyPointAdapter___call____SWIG_0(self, args); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Point2f, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PicoFlann_KeyPointAdapter___call____SWIG_1(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PicoFlann_KeyPointAdapter___call__'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::PicoFlann_KeyPointAdapter::operator ()(cv::KeyPoint const &,int) const\n" - " aruco::PicoFlann_KeyPointAdapter::operator ()(cv::Point2f const &,int) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_PicoFlann_KeyPointAdapter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::PicoFlann_KeyPointAdapter *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_PicoFlann_KeyPointAdapter")) SWIG_fail; - result = (aruco::PicoFlann_KeyPointAdapter *)new aruco::PicoFlann_KeyPointAdapter(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_PicoFlann_KeyPointAdapter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::PicoFlann_KeyPointAdapter *arg1 = (aruco::PicoFlann_KeyPointAdapter *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_PicoFlann_KeyPointAdapter",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PicoFlann_KeyPointAdapter" "', argument " "1"" of type '" "aruco::PicoFlann_KeyPointAdapter *""'"); - } - arg1 = reinterpret_cast< aruco::PicoFlann_KeyPointAdapter * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *PicoFlann_KeyPointAdapter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__PicoFlann_KeyPointAdapter, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_FractalPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_FractalPoseTracker")) SWIG_fail; - result = (aruco::FractalPoseTracker *)new aruco::FractalPoseTracker(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalPoseTracker, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_setParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - aruco::CameraParameters *arg2 = 0 ; - FractalMarkerSet *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_setParams",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_setParams" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__CameraParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_setParams" "', argument " "2"" of type '" "aruco::CameraParameters const &""'"); - } - arg2 = reinterpret_cast< aruco::CameraParameters * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FractalMarkerSet, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_setParams" "', argument " "3"" of type '" "FractalMarkerSet const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_setParams" "', argument " "3"" of type '" "FractalMarkerSet const &""'"); - } - arg3 = reinterpret_cast< FractalMarkerSet * >(argp3); - (arg1)->setParams((aruco::CameraParameters const &)*arg2,(FractalMarkerSet const &)*arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalInnerPose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - cv::Ptr< aruco::MarkerDetector > arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int res3 = SWIG_OLDOBJ ; - bool val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalPoseTracker_fractalInnerPose",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } else { - cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res3 = swig::asptr(obj2, &ptr); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg3 = ptr; - } - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - result = (bool)(arg1)->fractalInnerPose(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg3,arg4); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - if (SWIG_IsNewObj(res3)) delete arg3; - return resultobj; -fail: - if (SWIG_IsNewObj(res3)) delete arg3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalInnerPose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - cv::Ptr< aruco::MarkerDetector > arg2 ; - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int res3 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_fractalInnerPose",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } else { - cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - { - std::vector< aruco::Marker,std::allocator< aruco::Marker > > *ptr = (std::vector< aruco::Marker,std::allocator< aruco::Marker > > *)0; - res3 = swig::asptr(obj2, &ptr); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalInnerPose" "', argument " "3"" of type '" "std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &""'"); - } - arg3 = ptr; - } - result = (bool)(arg1)->fractalInnerPose(arg2,(std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)*arg3); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - if (SWIG_IsNewObj(res3)) delete arg3; - return resultobj; -fail: - if (SWIG_IsNewObj(res3)) delete arg3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalInnerPose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = swig::asptr(argv[2], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalPoseTracker_fractalInnerPose__SWIG_1(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = swig::asptr(argv[2], (std::vector< aruco::Marker,std::allocator< aruco::Marker > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalPoseTracker_fractalInnerPose__SWIG_0(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_fractalInnerPose'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalPoseTracker::fractalInnerPose(cv::Ptr< aruco::MarkerDetector > const,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &,bool)\n" - " aruco::FractalPoseTracker::fractalInnerPose(cv::Ptr< aruco::MarkerDetector > const,std::vector< aruco::Marker,std::allocator< aruco::Marker > > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_ROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - SwigValueWrapper< std::vector< cv::Mat,std::allocator< cv::Mat > > > arg2 ; - cv::Mat *arg3 = 0 ; - std::vector< cv::Point2f,std::allocator< cv::Point2f > > *arg4 = 0 ; - cv::Point2f *arg5 = 0 ; - float *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - uchar *data_ptr3 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FractalPoseTracker_ROI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_ROI" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_ROI" "', argument " "2"" of type '" "std::vector< cv::Mat,std::allocator< cv::Mat > > const""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "2"" of type '" "std::vector< cv::Mat,std::allocator< cv::Mat > > const""'"); - } else { - std::vector< cv::Mat,std::allocator< cv::Mat > > * temp = reinterpret_cast< std::vector< cv::Mat,std::allocator< cv::Mat > > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - { - arg3 = array_to_mat(obj2); - if (arg3 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr3 = arg3->data; - } - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_ROI" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "4"" of type '" "std::vector< cv::Point2f,std::allocator< cv::Point2f > > &""'"); - } - arg4 = reinterpret_cast< std::vector< cv::Point2f,std::allocator< cv::Point2f > > * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cv__Point2f, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_ROI" "', argument " "5"" of type '" "cv::Point2f &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "5"" of type '" "cv::Point2f &""'"); - } - arg5 = reinterpret_cast< cv::Point2f * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_float, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FractalPoseTracker_ROI" "', argument " "6"" of type '" "float &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_ROI" "', argument " "6"" of type '" "float &""'"); - } - arg6 = reinterpret_cast< float * >(argp6); - (arg1)->ROI(arg2,*arg3,*arg4,*arg5,*arg6); - resultobj = SWIG_Py_Void(); - { - // check if the underlying data changed - if (data_ptr3 != arg3->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg3->rows, arg3->cols, arg3->type()); - SWIG_fail; - } - } - { - if (arg3 != NULL) - delete arg3; - } - return resultobj; -fail: - { - if (arg3 != NULL) - delete arg3; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *arg3 = 0 ; - bool arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - int val5 ; - int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalPoseTracker_assignClass",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_assignClass" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); - } - arg3 = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalPoseTracker_assignClass" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_int(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FractalPoseTracker_assignClass" "', argument " "5"" of type '" "int""'"); - } - arg5 = static_cast< int >(val5); - (arg1)->assignClass((cv::Mat const &)*arg2,*arg3,arg4,arg5); - resultobj = SWIG_Py_Void(); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *arg3 = 0 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalPoseTracker_assignClass",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_assignClass" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); - } - arg3 = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp3); - ecode4 = SWIG_AsVal_bool(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalPoseTracker_assignClass" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - (arg1)->assignClass((cv::Mat const &)*arg2,*arg3,arg4); - resultobj = SWIG_Py_Void(); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - cv::Mat *arg2 = 0 ; - std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_assignClass",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_assignClass" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_assignClass" "', argument " "3"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &""'"); - } - arg3 = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp3); - (arg1)->assignClass((cv::Mat const &)*arg2,*arg3); - resultobj = SWIG_Py_Void(); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_assignClass(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalPoseTracker_assignClass__SWIG_2(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalPoseTracker_assignClass__SWIG_1(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = true;//is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalPoseTracker_assignClass__SWIG_0(self, args); - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_assignClass'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalPoseTracker::assignClass(cv::Mat const &,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &,bool,int)\n" - " aruco::FractalPoseTracker::assignClass(cv::Mat const &,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &,bool)\n" - " aruco::FractalPoseTracker::assignClass(cv::Mat const &,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - int arg2 ; - SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; - SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; - uint32_t arg5 ; - float arg6 ; - float arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 ; - int res3 = 0 ; - void *argp4 ; - int res4 = 0 ; - void *argp5 ; - int res5 = 0 ; - float val6 ; - int ecode6 = 0 ; - float val7 ; - int ecode7 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } else { - std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } else { - std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); - arg4 = *temp; - if (SWIG_IsNewObj(res4)) delete temp; - } - } - { - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_uint32_t, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); - } else { - uint32_t * temp = reinterpret_cast< uint32_t * >(argp5); - arg5 = *temp; - if (SWIG_IsNewObj(res5)) delete temp; - } - } - ecode6 = SWIG_AsVal_float(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "6"" of type '" "float""'"); - } - arg6 = static_cast< float >(val6); - ecode7 = SWIG_AsVal_float(obj6, &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "7"" of type '" "float""'"); - } - arg7 = static_cast< float >(val7); - result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4,arg5,arg6,arg7); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - int arg2 ; - SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; - SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; - uint32_t arg5 ; - float arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 ; - int res3 = 0 ; - void *argp4 ; - int res4 = 0 ; - void *argp5 ; - int res5 = 0 ; - float val6 ; - int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } else { - std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } else { - std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); - arg4 = *temp; - if (SWIG_IsNewObj(res4)) delete temp; - } - } - { - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_uint32_t, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); - } else { - uint32_t * temp = reinterpret_cast< uint32_t * >(argp5); - arg5 = *temp; - if (SWIG_IsNewObj(res5)) delete temp; - } - } - ecode6 = SWIG_AsVal_float(obj5, &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "6"" of type '" "float""'"); - } - arg6 = static_cast< float >(val6); - result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4,arg5,arg6); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - int arg2 ; - SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; - SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; - uint32_t arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 ; - int res3 = 0 ; - void *argp4 ; - int res4 = 0 ; - void *argp5 ; - int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } else { - std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } else { - std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); - arg4 = *temp; - if (SWIG_IsNewObj(res4)) delete temp; - } - } - { - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_uint32_t, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "5"" of type '" "uint32_t""'"); - } else { - uint32_t * temp = reinterpret_cast< uint32_t * >(argp5); - arg5 = *temp; - if (SWIG_IsNewObj(res5)) delete temp; - } - } - result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4,arg5); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - int arg2 ; - SwigValueWrapper< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > > arg3 ; - SwigValueWrapper< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > > arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 ; - int res3 = 0 ; - void *argp4 ; - int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalPoseTracker_fractal_solve_ransac",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "3"" of type '" "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >""'"); - } else { - std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * temp = reinterpret_cast< std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractal_solve_ransac" "', argument " "4"" of type '" "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >""'"); - } else { - std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * temp = reinterpret_cast< std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > * >(argp4); - arg4 = *temp; - if (SWIG_IsNewObj(res4)) delete temp; - } - } - result = (arg1)->fractal_solve_ransac(arg2,arg3,arg4); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractal_solve_ransac(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 7) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_3(self, args); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_uint32_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_2(self, args); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_uint32_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_1(self, args); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_uint32_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_float(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_float(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalPoseTracker_fractal_solve_ransac__SWIG_0(self, args); - } - } - } - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_fractal_solve_ransac'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >,uint32_t,float,float)\n" - " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >,uint32_t,float)\n" - " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >,uint32_t)\n" - " aruco::FractalPoseTracker::fractal_solve_ransac(int,std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > >,std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > >)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - cv::Ptr< aruco::MarkerDetector > arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalPoseTracker_fractalRefinement",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } else { - cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - result = (bool)(arg1)->fractalRefinement(arg2,arg3); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - cv::Ptr< aruco::MarkerDetector > arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalPoseTracker_fractalRefinement",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalPoseTracker_fractalRefinement" "', argument " "2"" of type '" "cv::Ptr< aruco::MarkerDetector > const""'"); - } else { - cv::Ptr< aruco::MarkerDetector > * temp = reinterpret_cast< cv::Ptr< aruco::MarkerDetector > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - result = (bool)(arg1)->fractalRefinement(arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_fractalRefinement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalPoseTracker_fractalRefinement__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalPoseTracker, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__PtrT_aruco__MarkerDetector_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalPoseTracker_fractalRefinement__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalPoseTracker_fractalRefinement'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalPoseTracker::fractalRefinement(cv::Ptr< aruco::MarkerDetector > const,int)\n" - " aruco::FractalPoseTracker::fractalRefinement(cv::Ptr< aruco::MarkerDetector > const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_getRvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_getRvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_getRvec" "', argument " "1"" of type '" "aruco::FractalPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - result = ((aruco::FractalPoseTracker const *)arg1)->getRvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_getTvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_getTvec",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_getTvec" "', argument " "1"" of type '" "aruco::FractalPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - result = ((aruco::FractalPoseTracker const *)arg1)->getTvec(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_getInner3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - SwigValueWrapper< std::vector< cv::Point3f,std::allocator< cv::Point3f > > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_getInner3d",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_getInner3d" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - result = (arg1)->getInner3d(); - resultobj = SWIG_NewPointerObj((new std::vector< cv::Point3f,std::allocator< cv::Point3f > >(static_cast< const std::vector< cv::Point3f,std::allocator< cv::Point3f > >& >(result))), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalPoseTracker_isPoseValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalPoseTracker_isPoseValid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalPoseTracker_isPoseValid" "', argument " "1"" of type '" "aruco::FractalPoseTracker const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - result = (bool)((aruco::FractalPoseTracker const *)arg1)->isPoseValid(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FractalPoseTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalPoseTracker *arg1 = (aruco::FractalPoseTracker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalPoseTracker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalPoseTracker, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalPoseTracker" "', argument " "1"" of type '" "aruco::FractalPoseTracker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalPoseTracker * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *FractalPoseTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalPoseTracker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - cv::Ptr< aruco::FractalMarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_create",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerLabeler_create" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::FractalMarkerLabeler::create(arg1); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::FractalMarkerLabeler >(static_cast< const cv::Ptr< aruco::FractalMarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__FractalMarkerLabeler_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - FractalMarkerSet::CONF_TYPES arg1 ; - void *argp1 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Ptr< aruco::FractalMarkerLabeler > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_create",&obj0)) SWIG_fail; - { - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FractalMarkerSet__CONF_TYPES, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_create" "', argument " "1"" of type '" "FractalMarkerSet::CONF_TYPES""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_create" "', argument " "1"" of type '" "FractalMarkerSet::CONF_TYPES""'"); - } else { - FractalMarkerSet::CONF_TYPES * temp = reinterpret_cast< FractalMarkerSet::CONF_TYPES * >(argp1); - arg1 = *temp; - if (SWIG_IsNewObj(res1)) delete temp; - } - } - result = aruco::FractalMarkerLabeler::create(arg1); - resultobj = SWIG_NewPointerObj((new cv::Ptr< aruco::FractalMarkerLabeler >(static_cast< const cv::Ptr< aruco::FractalMarkerLabeler >& >(result))), SWIGTYPE_p_cv__PtrT_aruco__FractalMarkerLabeler_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_create(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FractalMarkerSet__CONF_TYPES, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalMarkerLabeler_create__SWIG_1(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalMarkerLabeler_create__SWIG_0(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerLabeler_create'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalMarkerLabeler::create(std::string)\n" - " aruco::FractalMarkerLabeler::create(FractalMarkerSet::CONF_TYPES)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_setConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; - FractalMarkerSet *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerLabeler_setConfiguration",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_setConfiguration" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FractalMarkerSet, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerLabeler_setConfiguration" "', argument " "2"" of type '" "FractalMarkerSet const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_setConfiguration" "', argument " "2"" of type '" "FractalMarkerSet const &""'"); - } - arg2 = reinterpret_cast< FractalMarkerSet * >(argp2); - (arg1)->setConfiguration((FractalMarkerSet const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FractalMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalMarkerLabeler",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalMarkerLabeler" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_getName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_getName" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); - result = ((aruco::FractalMarkerLabeler const *)arg1)->getName(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_detect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; - cv::Mat *arg2 = 0 ; - int *arg3 = 0 ; - int *arg4 = 0 ; - std::string *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOOOO:FractalMarkerLabeler_detect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_detect" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - } - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FractalMarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_detect" "', argument " "3"" of type '" "int &""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalMarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_detect" "', argument " "4"" of type '" "int &""'"); - } - arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FractalMarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler_detect" "', argument " "5"" of type '" "std::string &""'"); - } - arg5 = reinterpret_cast< std::string * >(argp5); - result = (bool)(arg1)->detect((cv::Mat const &)*arg2,*arg3,*arg4,*arg5); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - { - - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler_getNSubdivisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler_getNSubdivisions",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler_getNSubdivisions" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); - result = (int)((aruco::FractalMarkerLabeler const *)arg1)->getNSubdivisions(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler__fractalMarkerSet_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; - FractalMarkerSet arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerLabeler__fractalMarkerSet_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler__fractalMarkerSet_set" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FractalMarkerSet, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerLabeler__fractalMarkerSet_set" "', argument " "2"" of type '" "FractalMarkerSet""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerLabeler__fractalMarkerSet_set" "', argument " "2"" of type '" "FractalMarkerSet""'"); - } else { - FractalMarkerSet * temp = reinterpret_cast< FractalMarkerSet * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->_fractalMarkerSet = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerLabeler__fractalMarkerSet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *arg1 = (aruco::FractalMarkerLabeler *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerLabeler__fractalMarkerSet_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerLabeler, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerLabeler__fractalMarkerSet_get" "', argument " "1"" of type '" "aruco::FractalMarkerLabeler *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerLabeler * >(argp1); - result = ((arg1)->_fractalMarkerSet); - resultobj = SWIG_NewPointerObj((new FractalMarkerSet(static_cast< const FractalMarkerSet& >(result))), SWIGTYPE_p_FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FractalMarkerLabeler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerLabeler *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_FractalMarkerLabeler")) SWIG_fail; - result = (aruco::FractalMarkerLabeler *)new aruco::FractalMarkerLabeler(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarkerLabeler, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *FractalMarkerLabeler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalMarkerLabeler, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - SwigValueWrapper< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > > arg2 ; - float arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - float val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_create",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_create" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_create" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_create" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >""'"); - } else { - std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * temp = reinterpret_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_float(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_create" "', argument " "3"" of type '" "float""'"); - } - arg3 = static_cast< float >(val3); - (arg1)->create(arg2,arg3); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_configureMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - int arg2 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalMarkerSet_configureMat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_configureMat" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_configureMat" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_configureMat" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - ecode4 = SWIG_AsVal_int(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FractalMarkerSet_configureMat" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - result = (arg1)->configureMat(arg2,arg3,arg4); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_configureMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_configureMat",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_configureMat" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_configureMat" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_configureMat" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - result = (arg1)->configureMat(arg2,arg3); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_configureMat(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalMarkerSet_configureMat__SWIG_1(self, args); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalMarkerSet_configureMat__SWIG_0(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerSet_configureMat'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalMarkerSet::configureMat(int,int,int)\n" - " aruco::FractalMarkerSet::configureMat(int,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_dstMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - cv::Mat arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_dstMarker",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_dstMarker" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - result = (int)(arg1)->dstMarker(arg2); - resultobj = SWIG_From_int(static_cast< int >(result)); - { - - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_dstMarkerToMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - cv::Mat arg2 ; - cv::Mat arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - cv::Mat *mat3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_dstMarkerToMarker",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_dstMarkerToMarker" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - { - mat3 = array_to_mat(obj2); - if (mat3 == NULL) - SWIG_fail; - arg3 = *mat3; - } - result = (int)(arg1)->dstMarkerToMarker(arg2,arg3); - resultobj = SWIG_From_int(static_cast< int >(result)); - { - - } - { - - } - { - if (mat2 != NULL) - delete mat2; - } - { - if (mat3 != NULL) - delete mat3; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - { - if (mat3 != NULL) - delete mat3; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_dstMarkerToFractalDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - cv::Mat arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - cv::Mat *mat2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_dstMarkerToFractalDict",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_dstMarkerToFractalDict" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - result = (int)(arg1)->dstMarkerToFractalDict(arg2); - resultobj = SWIG_From_int(static_cast< int >(result)); - { - - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet__toStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet__toStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__FractalMarkerSet, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet__toStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__toStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet__toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__toStream" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - aruco::FractalMarkerSet::_toStream(*arg1,*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet__fromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet__fromStream",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_aruco__FractalMarkerSet, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet__fromStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__fromStream" "', argument " "1"" of type '" "aruco::FractalMarkerSet &""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet__fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet__fromStream" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - aruco::FractalMarkerSet::_fromStream(*arg1,*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_isPredefinedConfigurationString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isPredefinedConfigurationString",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_isPredefinedConfigurationString" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (bool)aruco::FractalMarkerSet::isPredefinedConfigurationString(arg1); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getTypeString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet::CONF_TYPES arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getTypeString",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FractalMarkerSet_getTypeString" "', argument " "1"" of type '" "aruco::FractalMarkerSet::CONF_TYPES""'"); - } - arg1 = static_cast< aruco::FractalMarkerSet::CONF_TYPES >(val1); - result = aruco::FractalMarkerSet::getTypeString(arg1); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::FractalMarkerSet::CONF_TYPES result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getTypeFromString",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_getTypeFromString" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::FractalMarkerSet::CONF_TYPES)aruco::FractalMarkerSet::getTypeFromString(arg1); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_load",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_load" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::FractalMarkerSet::load(arg1); - resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_loadPredefined__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_loadPredefined",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_loadPredefined" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::FractalMarkerSet::loadPredefined(arg1); - resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_loadPredefined__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet::CONF_TYPES arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - aruco::FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_loadPredefined",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FractalMarkerSet_loadPredefined" "', argument " "1"" of type '" "aruco::FractalMarkerSet::CONF_TYPES""'"); - } - arg1 = static_cast< aruco::FractalMarkerSet::CONF_TYPES >(val1); - result = aruco::FractalMarkerSet::loadPredefined(arg1); - resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_loadPredefined(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalMarkerSet_loadPredefined__SWIG_1(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FractalMarkerSet_loadPredefined__SWIG_0(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerSet_loadPredefined'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalMarkerSet::loadPredefined(std::string)\n" - " aruco::FractalMarkerSet::loadPredefined(aruco::FractalMarkerSet::CONF_TYPES)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_readFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_readFromFile",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FractalMarkerSet_readFromFile" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::FractalMarkerSet::readFromFile(arg1); - resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_saveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - cv::FileStorage *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_saveToFile",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_saveToFile" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__FileStorage, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_saveToFile" "', argument " "2"" of type '" "cv::FileStorage &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_saveToFile" "', argument " "2"" of type '" "cv::FileStorage &""'"); - } - arg2 = reinterpret_cast< cv::FileStorage * >(argp2); - (arg1)->saveToFile(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_fractalMarkerCollection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - std::map< int,FractalMarker > arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_fractalMarkerCollection_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_fractalMarkerCollection_set" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_FractalMarker_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_fractalMarkerCollection_set" "', argument " "2"" of type '" "std::map< int,FractalMarker >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_fractalMarkerCollection_set" "', argument " "2"" of type '" "std::map< int,FractalMarker >""'"); - } else { - std::map< int,FractalMarker > * temp = reinterpret_cast< std::map< int,FractalMarker > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->fractalMarkerCollection = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_fractalMarkerCollection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::map< int,FractalMarker > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_fractalMarkerCollection_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_fractalMarkerCollection_get" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = ((arg1)->fractalMarkerCollection); - resultobj = SWIG_NewPointerObj((new std::map< int,FractalMarker >(static_cast< const std::map< int,FractalMarker >& >(result))), SWIGTYPE_p_std__mapT_int_FractalMarker_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_nbits_fractalMarkerIDs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - std::map< int,std::vector< int,std::allocator< int > > > arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_nbits_fractalMarkerIDs_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_set" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_set" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_set" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > >""'"); - } else { - std::map< int,std::vector< int,std::allocator< int > > > * temp = reinterpret_cast< std::map< int,std::vector< int,std::allocator< int > > > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->nbits_fractalMarkerIDs = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_nbits_fractalMarkerIDs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::map< int,std::vector< int,std::allocator< int > > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_nbits_fractalMarkerIDs_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_nbits_fractalMarkerIDs_get" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = ((arg1)->nbits_fractalMarkerIDs); - resultobj = SWIG_NewPointerObj((new std::map< int,std::vector< int,std::allocator< int > > >(static_cast< const std::map< int,std::vector< int,std::allocator< int > > >& >(result))), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_isExpressedInMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isExpressedInMeters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isExpressedInMeters" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (bool)((aruco::FractalMarkerSet const *)arg1)->isExpressedInMeters(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_isExpressedInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isExpressedInPixels",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isExpressedInPixels" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (bool)((aruco::FractalMarkerSet const *)arg1)->isExpressedInPixels(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_isNormalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_isNormalize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isNormalize" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (bool)((aruco::FractalMarkerSet const *)arg1)->isNormalize(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_normalize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_normalize" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (arg1)->normalize(); - resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_convertToMeters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - float arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - float val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::FractalMarkerSet result; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_convertToMeters",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_convertToMeters" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - ecode2 = SWIG_AsVal_float(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_convertToMeters" "', argument " "2"" of type '" "float""'"); - } - arg2 = static_cast< float >(val2); - result = (arg1)->convertToMeters(arg2); - resultobj = SWIG_NewPointerObj((new aruco::FractalMarkerSet(static_cast< const aruco::FractalMarkerSet& >(result))), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getConfigurations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SwigValueWrapper< std::vector< std::string,std::allocator< std::string > > > result; - - if (!PyArg_ParseTuple(args,(char *)":FractalMarkerSet_getConfigurations")) SWIG_fail; - result = aruco::FractalMarkerSet::getConfigurations(); - resultobj = SWIG_NewPointerObj((new std::vector< std::string,std::allocator< std::string > >(static_cast< const std::vector< std::string,std::allocator< std::string > >& >(result))), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - float result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getFractalSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getFractalSize" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (float)((aruco::FractalMarkerSet const *)arg1)->getFractalSize(); - resultobj = SWIG_From_float(static_cast< float >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_nBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_nBits",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_nBits" "', argument " "1"" of type '" "aruco::FractalMarkerSet const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (int)((aruco::FractalMarkerSet const *)arg1)->nBits(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_isFractalMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - cv::Mat *arg2 = 0 ; - int arg3 ; - int *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - uchar *data_ptr2 ; - int val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:FractalMarkerSet_isFractalMarker",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - { - arg2 = array_to_mat(obj1); - if (arg2 == NULL) - SWIG_fail; - // save dataptr to check whether it changed - data_ptr2 = arg2->data; - } - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "4"" of type '" "int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarkerSet_isFractalMarker" "', argument " "4"" of type '" "int &""'"); - } - arg4 = reinterpret_cast< int * >(argp4); - result = (bool)(arg1)->isFractalMarker(*arg2,arg3,*arg4); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - { - // check if the underlying data changed - if (data_ptr2 != arg2->data) { - // TODO don't fail if we can reallocate the underlying memory - // (not always possible due to the way NumPy does reference counting) - PyErr_Format(PyExc_RuntimeError, - "Underlying data changed. Please make sure that the " - "input data is of correct size and type: %d %d %d", - arg2->rows, arg2->cols, arg2->type()); - SWIG_fail; - } - } - { - if (arg2 != NULL) - delete arg2; - } - return resultobj; -fail: - { - if (arg2 != NULL) - delete arg2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getInnerCorners(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_getInnerCorners",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getInnerCorners" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (arg1)->getInnerCorners(); - resultobj = SWIG_NewPointerObj((new std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > >(static_cast< const std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > >& >(result))), SWIGTYPE_p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - int arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:FractalMarkerSet_getFractalMarkerImage",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - result = (arg1)->getFractalMarkerImage(arg2,arg3); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_getFractalMarkerImage",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_getFractalMarkerImage" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (arg1)->getFractalMarkerImage(arg2); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_getFractalMarkerImage(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__FractalMarkerSet, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FractalMarkerSet_getFractalMarkerImage__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FractalMarkerSet_getFractalMarkerImage'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalMarkerSet::getFractalMarkerImage(int,bool)\n" - " aruco::FractalMarkerSet::getFractalMarkerImage(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_mInfoType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarkerSet_mInfoType_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_mInfoType_set" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FractalMarkerSet_mInfoType_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - if (arg1) (arg1)->mInfoType = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarkerSet_mInfoType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarkerSet_mInfoType_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarkerSet_mInfoType_get" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - result = (int) ((arg1)->mInfoType); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FractalMarkerSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_FractalMarkerSet")) SWIG_fail; - result = (aruco::FractalMarkerSet *)new aruco::FractalMarkerSet(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FractalMarkerSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarkerSet *arg1 = (aruco::FractalMarkerSet *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalMarkerSet",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalMarkerSet" "', argument " "1"" of type '" "aruco::FractalMarkerSet *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarkerSet * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *FractalMarkerSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalMarkerSet, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_FractalMarker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_FractalMarker")) SWIG_fail; - result = (aruco::FractalMarker *)new aruco::FractalMarker(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarker, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FractalMarker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - cv::Mat arg2 ; - SwigValueWrapper< std::vector< cv::Point3f,std::allocator< cv::Point3f > > > arg3 ; - std::vector< int,std::allocator< int > > arg4 ; - int val1 ; - int ecode1 = 0 ; - cv::Mat *mat2 ; - void *argp3 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - aruco::FractalMarker *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FractalMarker",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FractalMarker" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - { - mat2 = array_to_mat(obj1); - if (mat2 == NULL) - SWIG_fail; - arg2 = *mat2; - } - { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FractalMarker" "', argument " "3"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > >""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FractalMarker" "', argument " "3"" of type '" "std::vector< cv::Point3f,std::allocator< cv::Point3f > >""'"); - } else { - std::vector< cv::Point3f,std::allocator< cv::Point3f > > * temp = reinterpret_cast< std::vector< cv::Point3f,std::allocator< cv::Point3f > > * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - { - std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0; - int res = swig::asptr(obj3, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FractalMarker" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); - } - arg4 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::FractalMarker *)new aruco::FractalMarker(arg1,arg2,arg3,arg4); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__FractalMarker, SWIG_POINTER_NEW | 0 ); - { - - } - { - if (mat2 != NULL) - delete mat2; - } - return resultobj; -fail: - { - if (mat2 != NULL) - delete mat2; - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FractalMarker(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_FractalMarker__SWIG_0(self, args); - } - if (argc == 4) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = is_array(argv[1]) || PySequence_Check(argv[1]); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FractalMarker__SWIG_1(self, args); - } - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FractalMarker'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::FractalMarker::FractalMarker()\n" - " aruco::FractalMarker::FractalMarker(int,cv::Mat,std::vector< cv::Point3f,std::allocator< cv::Point3f > >,std::vector< int,std::allocator< int > >)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FractalMarker_addSubFractalMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; - aruco::FractalMarker arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:FractalMarker_addSubFractalMarker",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_addSubFractalMarker" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_aruco__FractalMarker, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FractalMarker_addSubFractalMarker" "', argument " "2"" of type '" "aruco::FractalMarker""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FractalMarker_addSubFractalMarker" "', argument " "2"" of type '" "aruco::FractalMarker""'"); - } else { - aruco::FractalMarker * temp = reinterpret_cast< aruco::FractalMarker * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - (arg1)->addSubFractalMarker(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarker_getInnerCorners(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - SwigValueWrapper< std::vector< cv::Point3f,std::allocator< cv::Point3f > > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_getInnerCorners",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_getInnerCorners" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); - result = (arg1)->getInnerCorners(); - resultobj = SWIG_NewPointerObj((new std::vector< cv::Point3f,std::allocator< cv::Point3f > >(static_cast< const std::vector< cv::Point3f,std::allocator< cv::Point3f > >& >(result))), SWIGTYPE_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarker_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_mat",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_mat" "', argument " "1"" of type '" "aruco::FractalMarker const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); - result = ((aruco::FractalMarker const *)arg1)->mat(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarker_mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - cv::Mat result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_mask",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_mask" "', argument " "1"" of type '" "aruco::FractalMarker const *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); - result = ((aruco::FractalMarker const *)arg1)->mask(); - { - PyObject* array = mat_to_array(result); - if (array == NULL) - SWIG_fail; - - // add a reference to the underlying cv::Mat so - // that the memory is not freed before the NumPy array - // is released or reassigned - cv::Mat *m = new cv::Mat(result); - // printf("created new mat object at %p\n", m); -#ifdef CAPSULES_SUPPORTED - PyArray_BASE(array) = PyCapsule_New(m, NULL, delete_mat_capsule); -#else - PyArray_BASE(array) = PyCObject_FromVoidPtr(m, delete_mat); -#endif - - resultobj = array; - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarker_nBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_nBits",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_nBits" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); - result = (int)(arg1)->nBits(); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FractalMarker_subMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< int,std::allocator< int > > result; - - if (!PyArg_ParseTuple(args,(char *)"O:FractalMarker_subMarkers",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FractalMarker_subMarkers" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); - result = (arg1)->subMarkers(); - resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FractalMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::FractalMarker *arg1 = (aruco::FractalMarker *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_FractalMarker",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__FractalMarker, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractalMarker" "', argument " "1"" of type '" "aruco::FractalMarker *""'"); - } - arg1 = reinterpret_cast< aruco::FractalMarker * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *FractalMarker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__FractalMarker, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_ScopeTimer_begin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - std::chrono::high_resolution_clock::time_point arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_begin_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_begin_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopeTimer_begin_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopeTimer_begin_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); - } else { - std::chrono::high_resolution_clock::time_point * temp = reinterpret_cast< std::chrono::high_resolution_clock::time_point * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->begin = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_begin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::chrono::high_resolution_clock::time_point result; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_begin_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_begin_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - result = ((arg1)->begin); - resultobj = SWIG_NewPointerObj((new std::chrono::high_resolution_clock::time_point(static_cast< const std::chrono::high_resolution_clock::time_point& >(result))), SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_end_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - std::chrono::high_resolution_clock::time_point arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_end_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_end_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopeTimer_end_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopeTimer_end_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); - } else { - std::chrono::high_resolution_clock::time_point * temp = reinterpret_cast< std::chrono::high_resolution_clock::time_point * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->end = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_end_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::chrono::high_resolution_clock::time_point result; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_end_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_end_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - result = ((arg1)->end); - resultobj = SWIG_NewPointerObj((new std::chrono::high_resolution_clock::time_point(static_cast< const std::chrono::high_resolution_clock::time_point& >(result))), SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_name_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_name_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopeTimer_name_set" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopeTimer_name_set" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = ptr; - } - if (arg1) (arg1)->name = *arg2; - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_name_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_name_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - result = (std::string *) & ((arg1)->name); - resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_use_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_use_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_use_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopeTimer_use_set" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - if (arg1) (arg1)->use = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_use_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_use_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_use_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - result = (bool) ((arg1)->use); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_sc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - aruco::ScopeTimer::SCALE arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopeTimer_sc_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_sc_set" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopeTimer_sc_set" "', argument " "2"" of type '" "aruco::ScopeTimer::SCALE""'"); - } - arg2 = static_cast< aruco::ScopeTimer::SCALE >(val2); - if (arg1) (arg1)->sc = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopeTimer_sc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::ScopeTimer::SCALE result; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopeTimer_sc_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopeTimer_sc_get" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - result = (aruco::ScopeTimer::SCALE) ((arg1)->sc); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopeTimer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - bool arg2 ; - aruco::ScopeTimer::SCALE arg3 ; - bool val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - aruco::ScopeTimer *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:new_ScopeTimer",&obj0,&obj1,&obj2)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopeTimer" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopeTimer" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScopeTimer" "', argument " "3"" of type '" "aruco::ScopeTimer::SCALE""'"); - } - arg3 = static_cast< aruco::ScopeTimer::SCALE >(val3); - result = (aruco::ScopeTimer *)new aruco::ScopeTimer(arg1,arg2,arg3); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopeTimer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - bool arg2 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::ScopeTimer *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_ScopeTimer",&obj0,&obj1)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopeTimer" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopeTimer" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - result = (aruco::ScopeTimer *)new aruco::ScopeTimer(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopeTimer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::ScopeTimer *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopeTimer",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopeTimer" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::ScopeTimer *)new aruco::ScopeTimer(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopeTimer(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ScopeTimer__SWIG_2(self, args); - } - } - if (argc == 2) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ScopeTimer__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ScopeTimer__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopeTimer'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::ScopeTimer::ScopeTimer(std::string,bool,aruco::ScopeTimer::SCALE)\n" - " aruco::ScopeTimer::ScopeTimer(std::string,bool)\n" - " aruco::ScopeTimer::ScopeTimer(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_ScopeTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopeTimer *arg1 = (aruco::ScopeTimer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopeTimer",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopeTimer, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopeTimer" "', argument " "1"" of type '" "aruco::ScopeTimer *""'"); - } - arg1 = reinterpret_cast< aruco::ScopeTimer * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ScopeTimer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__ScopeTimer, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_sc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - aruco::ScopedTimerEvents::SCALE arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_sc_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_sc_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedTimerEvents_sc_set" "', argument " "2"" of type '" "aruco::ScopedTimerEvents::SCALE""'"); - } - arg2 = static_cast< aruco::ScopedTimerEvents::SCALE >(val2); - if (arg1) (arg1)->sc = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_sc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - aruco::ScopedTimerEvents::SCALE result; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents_sc_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_sc_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - result = (aruco::ScopedTimerEvents::SCALE) ((arg1)->sc); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_vtimes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *arg2 = (std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_vtimes_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_vtimes_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents_vtimes_set" "', argument " "2"" of type '" "std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *""'"); - } - arg2 = reinterpret_cast< std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > * >(argp2); - if (arg1) (arg1)->vtimes = *arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_vtimes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents_vtimes_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_vtimes_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - result = (std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *)& ((arg1)->vtimes); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_names_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_names_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_names_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents_names_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); - } - arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2); - if (arg1) (arg1)->names = *arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_names_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::vector< std::string,std::allocator< std::string > > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents_names_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_names_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->names); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents__name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents__name_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents__name_set" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents__name_set" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedTimerEvents__name_set" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = ptr; - } - if (arg1) (arg1)->_name = *arg2; - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents__name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:ScopedTimerEvents__name_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents__name_get" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - result = (std::string *) & ((arg1)->_name); - resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - bool arg2 ; - aruco::ScopedTimerEvents::SCALE arg3 ; - bool val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - aruco::ScopedTimerEvents *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:new_ScopedTimerEvents",&obj0,&obj1,&obj2)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopedTimerEvents" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopedTimerEvents" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScopedTimerEvents" "', argument " "3"" of type '" "aruco::ScopedTimerEvents::SCALE""'"); - } - arg3 = static_cast< aruco::ScopedTimerEvents::SCALE >(val3); - result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(arg1,arg2,arg3); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - bool arg2 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - aruco::ScopedTimerEvents *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:new_ScopedTimerEvents",&obj0,&obj1)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopedTimerEvents" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScopedTimerEvents" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::ScopedTimerEvents *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedTimerEvents",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ScopedTimerEvents" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_ScopedTimerEvents")) SWIG_fail; - result = (aruco::ScopedTimerEvents *)new aruco::ScopedTimerEvents(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ScopedTimerEvents(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_ScopedTimerEvents__SWIG_3(self, args); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ScopedTimerEvents__SWIG_2(self, args); - } - } - if (argc == 2) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ScopedTimerEvents__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ScopedTimerEvents__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedTimerEvents'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::ScopedTimerEvents::ScopedTimerEvents(std::string,bool,aruco::ScopedTimerEvents::SCALE)\n" - " aruco::ScopedTimerEvents::ScopedTimerEvents(std::string,bool)\n" - " aruco::ScopedTimerEvents::ScopedTimerEvents(std::string)\n" - " aruco::ScopedTimerEvents::ScopedTimerEvents()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_add",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_add" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ScopedTimerEvents_add" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->add(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ScopedTimerEvents_addspaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedTimerEvents_addspaces",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedTimerEvents_addspaces" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedTimerEvents_addspaces" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedTimerEvents_addspaces" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); - } - arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2); - (arg1)->addspaces(*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_ScopedTimerEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::ScopedTimerEvents *arg1 = (aruco::ScopedTimerEvents *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopedTimerEvents",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopedTimerEvents" "', argument " "1"" of type '" "aruco::ScopedTimerEvents *""'"); - } - arg1 = reinterpret_cast< aruco::ScopedTimerEvents * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ScopedTimerEvents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__ScopedTimerEvents, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_Timer__s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - std::chrono::high_resolution_clock::time_point arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Timer__s_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__s_set" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer__s_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Timer__s_set" "', argument " "2"" of type '" "std::chrono::high_resolution_clock::time_point""'"); - } else { - std::chrono::high_resolution_clock::time_point * temp = reinterpret_cast< std::chrono::high_resolution_clock::time_point * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->_s = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer__s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::chrono::high_resolution_clock::time_point result; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer__s_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__s_get" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - result = ((arg1)->_s); - resultobj = SWIG_NewPointerObj((new std::chrono::high_resolution_clock::time_point(static_cast< const std::chrono::high_resolution_clock::time_point& >(result))), SWIGTYPE_p_std__chrono__high_resolution_clock__time_point, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_sum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Timer_sum_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_sum_set" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - ecode2 = SWIG_AsVal_double(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_sum_set" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - if (arg1) (arg1)->sum = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_sum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - double result; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer_sum_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_sum_get" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - result = (double) ((arg1)->sum); - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_n_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Timer_n_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_n_set" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - ecode2 = SWIG_AsVal_double(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_n_set" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - if (arg1) (arg1)->n = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - double result; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer_n_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_n_get" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - result = (double) ((arg1)->n); - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer__name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Timer__name_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__name_set" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer__name_set" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Timer__name_set" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = ptr; - } - if (arg1) (arg1)->_name = *arg2; - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; -fail: - if (SWIG_IsNewObj(res2)) delete arg2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer__name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - std::string *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer__name_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__name_get" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - result = (std::string *) & ((arg1)->_name); - resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Timer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_Timer")) SWIG_fail; - result = (aruco::Timer *)new aruco::Timer(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Timer, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Timer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - aruco::Timer *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_Timer",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Timer" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = (aruco::Timer *)new aruco::Timer(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_aruco__Timer, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Timer(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_Timer__SWIG_0(self, args); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Timer__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Timer'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Timer::Timer()\n" - " aruco::Timer::Timer(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Timer_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Timer_setName",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_setName" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Timer_setName" "', argument " "2"" of type '" "std::string""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - (arg1)->setName(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer_start",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_start" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - (arg1)->start(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer_end",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_end" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - (arg1)->end(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer__print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - aruco::Timer::SCALE arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:Timer__print",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__print" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer__print" "', argument " "2"" of type '" "aruco::Timer::SCALE""'"); - } - arg2 = static_cast< aruco::Timer::SCALE >(val2); - (arg1)->print(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer__print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer__print",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__print" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - (arg1)->print(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer__print(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Timer__print__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Timer__print__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Timer__print'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Timer::print(aruco::Timer::SCALE)\n" - " aruco::Timer::print()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Timer_getAverage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - aruco::Timer::SCALE arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - double result; - - if (!PyArg_ParseTuple(args,(char *)"OO:Timer_getAverage",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_getAverage" "', argument " "1"" of type '" "aruco::Timer const *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_getAverage" "', argument " "2"" of type '" "aruco::Timer::SCALE""'"); - } - arg2 = static_cast< aruco::Timer::SCALE >(val2); - result = (double)((aruco::Timer const *)arg1)->getAverage(arg2); - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_getAverage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - double result; - - if (!PyArg_ParseTuple(args,(char *)"O:Timer_getAverage",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_getAverage" "', argument " "1"" of type '" "aruco::Timer const *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - result = (double)((aruco::Timer const *)arg1)->getAverage(); - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Timer_getAverage(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Timer_getAverage__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_aruco__Timer, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Timer_getAverage__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Timer_getAverage'.\n" - " Possible C/C++ prototypes are:\n" - " aruco::Timer::getAverage(aruco::Timer::SCALE) const\n" - " aruco::Timer::getAverage() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - aruco::Timer *arg1 = (aruco::Timer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_Timer",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_aruco__Timer, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', argument " "1"" of type '" "aruco::Timer *""'"); - } - arg1 = reinterpret_cast< aruco::Timer * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_aruco__Timer, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap___pf_aruco_methodName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - std::string arg1 ; - PyObject * obj0 = 0 ; - std::string result; - - if (!PyArg_ParseTuple(args,(char *)"O:__pf_aruco_methodName",&obj0)) SWIG_fail; - { - std::string *ptr = (std::string *)0; - int res = SWIG_AsPtr_std_string(obj0, &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "__pf_aruco_methodName" "', argument " "1"" of type '" "std::string""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - result = aruco::__pf_aruco_methodName(arg1); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); - return resultobj; -fail: - return NULL; -} - - -static PyMethodDef SwigMethods[] = { - { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, - { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL}, - { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL}, - { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL}, - { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL}, - { (char *)"VectorInt___bool__", _wrap_VectorInt___bool__, METH_VARARGS, NULL}, - { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL}, - { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL}, - { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL}, - { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL}, - { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL}, - { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL}, - { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL}, - { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL}, - { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL}, - { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL}, - { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL}, - { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL}, - { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL}, - { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL}, - { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL}, - { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL}, - { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL}, - { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL}, - { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL}, - { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL}, - { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL}, - { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL}, - { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL}, - { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL}, - { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL}, - { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL}, - { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL}, - { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL}, - { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL}, - { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL}, - { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL}, - { (char *)"CameraParameters_CameraMatrix_set", _wrap_CameraParameters_CameraMatrix_set, METH_VARARGS, NULL}, - { (char *)"CameraParameters_CameraMatrix_get", _wrap_CameraParameters_CameraMatrix_get, METH_VARARGS, NULL}, - { (char *)"CameraParameters_Distorsion_set", _wrap_CameraParameters_Distorsion_set, METH_VARARGS, NULL}, - { (char *)"CameraParameters_Distorsion_get", _wrap_CameraParameters_Distorsion_get, METH_VARARGS, NULL}, - { (char *)"CameraParameters_CamSize_set", _wrap_CameraParameters_CamSize_set, METH_VARARGS, NULL}, - { (char *)"CameraParameters_CamSize_get", _wrap_CameraParameters_CamSize_get, METH_VARARGS, NULL}, - { (char *)"CameraParameters_setParams", _wrap_CameraParameters_setParams, METH_VARARGS, NULL}, - { (char *)"new_CameraParameters", _wrap_new_CameraParameters, METH_VARARGS, NULL}, - { (char *)"CameraParameters_isValid", _wrap_CameraParameters_isValid, METH_VARARGS, NULL}, - { (char *)"CameraParameters_saveToFile", _wrap_CameraParameters_saveToFile, METH_VARARGS, NULL}, - { (char *)"CameraParameters_readFromXMLFile", _wrap_CameraParameters_readFromXMLFile, METH_VARARGS, NULL}, - { (char *)"CameraParameters_resize", _wrap_CameraParameters_resize, METH_VARARGS, NULL}, - { (char *)"CameraParameters_getCameraLocation", _wrap_CameraParameters_getCameraLocation, METH_VARARGS, NULL}, - { (char *)"CameraParameters_glGetProjectionMatrix", _wrap_CameraParameters_glGetProjectionMatrix, METH_VARARGS, NULL}, - { (char *)"CameraParameters_OgreGetProjectionMatrix", _wrap_CameraParameters_OgreGetProjectionMatrix, METH_VARARGS, NULL}, - { (char *)"CameraParameters_getRTMatrix", _wrap_CameraParameters_getRTMatrix, METH_VARARGS, NULL}, - { (char *)"CameraParameters_clear", _wrap_CameraParameters_clear, METH_VARARGS, NULL}, - { (char *)"delete_CameraParameters", _wrap_delete_CameraParameters, METH_VARARGS, NULL}, - { (char *)"CameraParameters_swigregister", CameraParameters_swigregister, METH_VARARGS, NULL}, - { (char *)"CvDrawingUtils_draw3dAxis", _wrap_CvDrawingUtils_draw3dAxis, METH_VARARGS, NULL}, - { (char *)"CvDrawingUtils_draw3dCube", _wrap_CvDrawingUtils_draw3dCube, METH_VARARGS, NULL}, - { (char *)"new_CvDrawingUtils", _wrap_new_CvDrawingUtils, METH_VARARGS, NULL}, - { (char *)"delete_CvDrawingUtils", _wrap_delete_CvDrawingUtils, METH_VARARGS, NULL}, - { (char *)"CvDrawingUtils_swigregister", CvDrawingUtils_swigregister, METH_VARARGS, NULL}, - { (char *)"Debug_init", _wrap_Debug_init, METH_VARARGS, NULL}, - { (char *)"Debug_setLevel", _wrap_Debug_setLevel, METH_VARARGS, NULL}, - { (char *)"Debug_getLevel", _wrap_Debug_getLevel, METH_VARARGS, NULL}, - { (char *)"Debug_addString", _wrap_Debug_addString, METH_VARARGS, NULL}, - { (char *)"Debug_getString", _wrap_Debug_getString, METH_VARARGS, NULL}, - { (char *)"Debug_getFileName", _wrap_Debug_getFileName, METH_VARARGS, NULL}, - { (char *)"new_Debug", _wrap_new_Debug, METH_VARARGS, NULL}, - { (char *)"delete_Debug", _wrap_delete_Debug, METH_VARARGS, NULL}, - { (char *)"Debug_swigregister", Debug_swigregister, METH_VARARGS, NULL}, - { (char *)"Dictionary__is", _wrap_Dictionary__is, METH_VARARGS, NULL}, - { (char *)"Dictionary_getType", _wrap_Dictionary_getType, METH_VARARGS, NULL}, - { (char *)"Dictionary_size", _wrap_Dictionary_size, METH_VARARGS, NULL}, - { (char *)"Dictionary_nbits", _wrap_Dictionary_nbits, METH_VARARGS, NULL}, - { (char *)"Dictionary_tau", _wrap_Dictionary_tau, METH_VARARGS, NULL}, - { (char *)"Dictionary_getName", _wrap_Dictionary_getName, METH_VARARGS, NULL}, - { (char *)"Dictionary_getMapCode", _wrap_Dictionary_getMapCode, METH_VARARGS, NULL}, - { (char *)"Dictionary_at", _wrap_Dictionary_at, METH_VARARGS, NULL}, - { (char *)"Dictionary_getMarkerImage_id", _wrap_Dictionary_getMarkerImage_id, METH_VARARGS, NULL}, - { (char *)"Dictionary_createMarkerMap", _wrap_Dictionary_createMarkerMap, METH_VARARGS, NULL}, - { (char *)"Dictionary_loadPredefined", _wrap_Dictionary_loadPredefined, METH_VARARGS, NULL}, - { (char *)"Dictionary_loadFromFile", _wrap_Dictionary_loadFromFile, METH_VARARGS, NULL}, - { (char *)"Dictionary_load", _wrap_Dictionary_load, METH_VARARGS, NULL}, - { (char *)"Dictionary_computeDictionaryDistance", _wrap_Dictionary_computeDictionaryDistance, METH_VARARGS, NULL}, - { (char *)"Dictionary_getTypeFromString", _wrap_Dictionary_getTypeFromString, METH_VARARGS, NULL}, - { (char *)"Dictionary_getTypeString", _wrap_Dictionary_getTypeString, METH_VARARGS, NULL}, - { (char *)"Dictionary_isPredefinedDictinaryString", _wrap_Dictionary_isPredefinedDictinaryString, METH_VARARGS, NULL}, - { (char *)"Dictionary_getDicTypes", _wrap_Dictionary_getDicTypes, METH_VARARGS, NULL}, - { (char *)"new_Dictionary", _wrap_new_Dictionary, METH_VARARGS, NULL}, - { (char *)"delete_Dictionary", _wrap_delete_Dictionary, METH_VARARGS, NULL}, - { (char *)"Dictionary_swigregister", Dictionary_swigregister, METH_VARARGS, NULL}, - { (char *)"Point2fVec_iterator", _wrap_Point2fVec_iterator, METH_VARARGS, NULL}, - { (char *)"Point2fVec___nonzero__", _wrap_Point2fVec___nonzero__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___bool__", _wrap_Point2fVec___bool__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___len__", _wrap_Point2fVec___len__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___getslice__", _wrap_Point2fVec___getslice__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___setslice__", _wrap_Point2fVec___setslice__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___delslice__", _wrap_Point2fVec___delslice__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___delitem__", _wrap_Point2fVec___delitem__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___getitem__", _wrap_Point2fVec___getitem__, METH_VARARGS, NULL}, - { (char *)"Point2fVec___setitem__", _wrap_Point2fVec___setitem__, METH_VARARGS, NULL}, - { (char *)"Point2fVec_pop", _wrap_Point2fVec_pop, METH_VARARGS, NULL}, - { (char *)"Point2fVec_append", _wrap_Point2fVec_append, METH_VARARGS, NULL}, - { (char *)"Point2fVec_empty", _wrap_Point2fVec_empty, METH_VARARGS, NULL}, - { (char *)"Point2fVec_size", _wrap_Point2fVec_size, METH_VARARGS, NULL}, - { (char *)"Point2fVec_swap", _wrap_Point2fVec_swap, METH_VARARGS, NULL}, - { (char *)"Point2fVec_begin", _wrap_Point2fVec_begin, METH_VARARGS, NULL}, - { (char *)"Point2fVec_end", _wrap_Point2fVec_end, METH_VARARGS, NULL}, - { (char *)"Point2fVec_rbegin", _wrap_Point2fVec_rbegin, METH_VARARGS, NULL}, - { (char *)"Point2fVec_rend", _wrap_Point2fVec_rend, METH_VARARGS, NULL}, - { (char *)"Point2fVec_clear", _wrap_Point2fVec_clear, METH_VARARGS, NULL}, - { (char *)"Point2fVec_get_allocator", _wrap_Point2fVec_get_allocator, METH_VARARGS, NULL}, - { (char *)"Point2fVec_pop_back", _wrap_Point2fVec_pop_back, METH_VARARGS, NULL}, - { (char *)"Point2fVec_erase", _wrap_Point2fVec_erase, METH_VARARGS, NULL}, - { (char *)"new_Point2fVec", _wrap_new_Point2fVec, METH_VARARGS, NULL}, - { (char *)"Point2fVec_push_back", _wrap_Point2fVec_push_back, METH_VARARGS, NULL}, - { (char *)"Point2fVec_front", _wrap_Point2fVec_front, METH_VARARGS, NULL}, - { (char *)"Point2fVec_back", _wrap_Point2fVec_back, METH_VARARGS, NULL}, - { (char *)"Point2fVec_assign", _wrap_Point2fVec_assign, METH_VARARGS, NULL}, - { (char *)"Point2fVec_resize", _wrap_Point2fVec_resize, METH_VARARGS, NULL}, - { (char *)"Point2fVec_insert", _wrap_Point2fVec_insert, METH_VARARGS, NULL}, - { (char *)"Point2fVec_reserve", _wrap_Point2fVec_reserve, METH_VARARGS, NULL}, - { (char *)"Point2fVec_capacity", _wrap_Point2fVec_capacity, METH_VARARGS, NULL}, - { (char *)"delete_Point2fVec", _wrap_delete_Point2fVec, METH_VARARGS, NULL}, - { (char *)"Point2fVec_swigregister", Point2fVec_swigregister, METH_VARARGS, NULL}, - { (char *)"MarkerVec_iterator", _wrap_MarkerVec_iterator, METH_VARARGS, NULL}, - { (char *)"MarkerVec___nonzero__", _wrap_MarkerVec___nonzero__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___bool__", _wrap_MarkerVec___bool__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___len__", _wrap_MarkerVec___len__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___getslice__", _wrap_MarkerVec___getslice__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___setslice__", _wrap_MarkerVec___setslice__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___delslice__", _wrap_MarkerVec___delslice__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___delitem__", _wrap_MarkerVec___delitem__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___getitem__", _wrap_MarkerVec___getitem__, METH_VARARGS, NULL}, - { (char *)"MarkerVec___setitem__", _wrap_MarkerVec___setitem__, METH_VARARGS, NULL}, - { (char *)"MarkerVec_pop", _wrap_MarkerVec_pop, METH_VARARGS, NULL}, - { (char *)"MarkerVec_append", _wrap_MarkerVec_append, METH_VARARGS, NULL}, - { (char *)"MarkerVec_empty", _wrap_MarkerVec_empty, METH_VARARGS, NULL}, - { (char *)"MarkerVec_size", _wrap_MarkerVec_size, METH_VARARGS, NULL}, - { (char *)"MarkerVec_swap", _wrap_MarkerVec_swap, METH_VARARGS, NULL}, - { (char *)"MarkerVec_begin", _wrap_MarkerVec_begin, METH_VARARGS, NULL}, - { (char *)"MarkerVec_end", _wrap_MarkerVec_end, METH_VARARGS, NULL}, - { (char *)"MarkerVec_rbegin", _wrap_MarkerVec_rbegin, METH_VARARGS, NULL}, - { (char *)"MarkerVec_rend", _wrap_MarkerVec_rend, METH_VARARGS, NULL}, - { (char *)"MarkerVec_clear", _wrap_MarkerVec_clear, METH_VARARGS, NULL}, - { (char *)"MarkerVec_get_allocator", _wrap_MarkerVec_get_allocator, METH_VARARGS, NULL}, - { (char *)"MarkerVec_pop_back", _wrap_MarkerVec_pop_back, METH_VARARGS, NULL}, - { (char *)"MarkerVec_erase", _wrap_MarkerVec_erase, METH_VARARGS, NULL}, - { (char *)"new_MarkerVec", _wrap_new_MarkerVec, METH_VARARGS, NULL}, - { (char *)"MarkerVec_push_back", _wrap_MarkerVec_push_back, METH_VARARGS, NULL}, - { (char *)"MarkerVec_front", _wrap_MarkerVec_front, METH_VARARGS, NULL}, - { (char *)"MarkerVec_back", _wrap_MarkerVec_back, METH_VARARGS, NULL}, - { (char *)"MarkerVec_assign", _wrap_MarkerVec_assign, METH_VARARGS, NULL}, - { (char *)"MarkerVec_resize", _wrap_MarkerVec_resize, METH_VARARGS, NULL}, - { (char *)"MarkerVec_insert", _wrap_MarkerVec_insert, METH_VARARGS, NULL}, - { (char *)"MarkerVec_reserve", _wrap_MarkerVec_reserve, METH_VARARGS, NULL}, - { (char *)"MarkerVec_capacity", _wrap_MarkerVec_capacity, METH_VARARGS, NULL}, - { (char *)"delete_MarkerVec", _wrap_delete_MarkerVec, METH_VARARGS, NULL}, - { (char *)"MarkerVec_swigregister", MarkerVec_swigregister, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_iterator", _wrap_VectorMarker3DInfo_iterator, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___nonzero__", _wrap_VectorMarker3DInfo___nonzero__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___bool__", _wrap_VectorMarker3DInfo___bool__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___len__", _wrap_VectorMarker3DInfo___len__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___getslice__", _wrap_VectorMarker3DInfo___getslice__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___setslice__", _wrap_VectorMarker3DInfo___setslice__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___delslice__", _wrap_VectorMarker3DInfo___delslice__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___delitem__", _wrap_VectorMarker3DInfo___delitem__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___getitem__", _wrap_VectorMarker3DInfo___getitem__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo___setitem__", _wrap_VectorMarker3DInfo___setitem__, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_pop", _wrap_VectorMarker3DInfo_pop, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_append", _wrap_VectorMarker3DInfo_append, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_empty", _wrap_VectorMarker3DInfo_empty, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_size", _wrap_VectorMarker3DInfo_size, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_swap", _wrap_VectorMarker3DInfo_swap, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_begin", _wrap_VectorMarker3DInfo_begin, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_end", _wrap_VectorMarker3DInfo_end, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_rbegin", _wrap_VectorMarker3DInfo_rbegin, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_rend", _wrap_VectorMarker3DInfo_rend, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_clear", _wrap_VectorMarker3DInfo_clear, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_get_allocator", _wrap_VectorMarker3DInfo_get_allocator, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_pop_back", _wrap_VectorMarker3DInfo_pop_back, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_erase", _wrap_VectorMarker3DInfo_erase, METH_VARARGS, NULL}, - { (char *)"new_VectorMarker3DInfo", _wrap_new_VectorMarker3DInfo, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_push_back", _wrap_VectorMarker3DInfo_push_back, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_front", _wrap_VectorMarker3DInfo_front, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_back", _wrap_VectorMarker3DInfo_back, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_assign", _wrap_VectorMarker3DInfo_assign, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_resize", _wrap_VectorMarker3DInfo_resize, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_insert", _wrap_VectorMarker3DInfo_insert, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_reserve", _wrap_VectorMarker3DInfo_reserve, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_capacity", _wrap_VectorMarker3DInfo_capacity, METH_VARARGS, NULL}, - { (char *)"delete_VectorMarker3DInfo", _wrap_delete_VectorMarker3DInfo, METH_VARARGS, NULL}, - { (char *)"VectorMarker3DInfo_swigregister", VectorMarker3DInfo_swigregister, METH_VARARGS, NULL}, - { (char *)"Marker_id_set", _wrap_Marker_id_set, METH_VARARGS, NULL}, - { (char *)"Marker_id_get", _wrap_Marker_id_get, METH_VARARGS, NULL}, - { (char *)"Marker_ssize_set", _wrap_Marker_ssize_set, METH_VARARGS, NULL}, - { (char *)"Marker_ssize_get", _wrap_Marker_ssize_get, METH_VARARGS, NULL}, - { (char *)"Marker_Rvec_set", _wrap_Marker_Rvec_set, METH_VARARGS, NULL}, - { (char *)"Marker_Rvec_get", _wrap_Marker_Rvec_get, METH_VARARGS, NULL}, - { (char *)"Marker_Tvec_set", _wrap_Marker_Tvec_set, METH_VARARGS, NULL}, - { (char *)"Marker_Tvec_get", _wrap_Marker_Tvec_get, METH_VARARGS, NULL}, - { (char *)"Marker_dict_info_set", _wrap_Marker_dict_info_set, METH_VARARGS, NULL}, - { (char *)"Marker_dict_info_get", _wrap_Marker_dict_info_get, METH_VARARGS, NULL}, - { (char *)"Marker_contourPoints_set", _wrap_Marker_contourPoints_set, METH_VARARGS, NULL}, - { (char *)"Marker_contourPoints_get", _wrap_Marker_contourPoints_get, METH_VARARGS, NULL}, - { (char *)"new_Marker", _wrap_new_Marker, METH_VARARGS, NULL}, - { (char *)"delete_Marker", _wrap_delete_Marker, METH_VARARGS, NULL}, - { (char *)"Marker_isValid", _wrap_Marker_isValid, METH_VARARGS, NULL}, - { (char *)"Marker_isPoseValid", _wrap_Marker_isPoseValid, METH_VARARGS, NULL}, - { (char *)"Marker_draw", _wrap_Marker_draw, METH_VARARGS, NULL}, - { (char *)"Marker_calculateExtrinsics", _wrap_Marker_calculateExtrinsics, METH_VARARGS, NULL}, - { (char *)"Marker_glGetModelViewMatrix", _wrap_Marker_glGetModelViewMatrix, METH_VARARGS, NULL}, - { (char *)"Marker_OgreGetPoseParameters", _wrap_Marker_OgreGetPoseParameters, METH_VARARGS, NULL}, - { (char *)"Marker_getCenter", _wrap_Marker_getCenter, METH_VARARGS, NULL}, - { (char *)"Marker_getPerimeter", _wrap_Marker_getPerimeter, METH_VARARGS, NULL}, - { (char *)"Marker_getArea", _wrap_Marker_getArea, METH_VARARGS, NULL}, - { (char *)"Marker_getRadius", _wrap_Marker_getRadius, METH_VARARGS, NULL}, - { (char *)"Marker___eq__", _wrap_Marker___eq__, METH_VARARGS, NULL}, - { (char *)"Marker_copyTo", _wrap_Marker_copyTo, METH_VARARGS, NULL}, - { (char *)"Marker_toStream", _wrap_Marker_toStream, METH_VARARGS, NULL}, - { (char *)"Marker_fromStream", _wrap_Marker_fromStream, METH_VARARGS, NULL}, - { (char *)"Marker_get3DPoints", _wrap_Marker_get3DPoints, METH_VARARGS, NULL}, - { (char *)"Marker_getTransformMatrix", _wrap_Marker_getTransformMatrix, METH_VARARGS, NULL}, - { (char *)"Marker___getitem__", _wrap_Marker___getitem__, METH_VARARGS, NULL}, - { (char *)"Marker_swigregister", Marker_swigregister, METH_VARARGS, NULL}, - { (char *)"new_MarkerDetector", _wrap_new_MarkerDetector, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_saveParamsToFile", _wrap_MarkerDetector_saveParamsToFile, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_loadParamsFromFile", _wrap_MarkerDetector_loadParamsFromFile, METH_VARARGS, NULL}, - { (char *)"delete_MarkerDetector", _wrap_delete_MarkerDetector, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_setDetectionMode", _wrap_MarkerDetector_setDetectionMode, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_getDetectionMode", _wrap_MarkerDetector_getDetectionMode, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_detect", _wrap_MarkerDetector_detect, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_getParameters", _wrap_MarkerDetector_getParameters, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_setDictionary", _wrap_MarkerDetector_setDictionary, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_getThresholdedImage", _wrap_MarkerDetector_getThresholdedImage, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_setMarkerLabeler", _wrap_MarkerDetector_setMarkerLabeler, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_getMarkerLabeler", _wrap_MarkerDetector_getMarkerLabeler, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_getCandidates", _wrap_MarkerDetector_getCandidates, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_getImagePyramid", _wrap_MarkerDetector_getImagePyramid, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_cornerUpsample", _wrap_MarkerDetector_cornerUpsample, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_toStream", _wrap_MarkerDetector_toStream, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_fromStream", _wrap_MarkerDetector_fromStream, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_setParameters", _wrap_MarkerDetector_setParameters, METH_VARARGS, NULL}, - { (char *)"MarkerDetector_swigregister", MarkerDetector_swigregister, METH_VARARGS, NULL}, - { (char *)"MarkerLabeler_create", _wrap_MarkerLabeler_create, METH_VARARGS, NULL}, - { (char *)"MarkerLabeler_detect", _wrap_MarkerLabeler_detect, METH_VARARGS, NULL}, - { (char *)"MarkerLabeler_getBestInputSize", _wrap_MarkerLabeler_getBestInputSize, METH_VARARGS, NULL}, - { (char *)"MarkerLabeler_getNSubdivisions", _wrap_MarkerLabeler_getNSubdivisions, METH_VARARGS, NULL}, - { (char *)"MarkerLabeler_getName", _wrap_MarkerLabeler_getName, METH_VARARGS, NULL}, - { (char *)"delete_MarkerLabeler", _wrap_delete_MarkerLabeler, METH_VARARGS, NULL}, - { (char *)"MarkerLabeler_swigregister", MarkerLabeler_swigregister, METH_VARARGS, NULL}, - { (char *)"new_FractalDetector", _wrap_new_FractalDetector, METH_VARARGS, NULL}, - { (char *)"FractalDetector_setConfiguration", _wrap_FractalDetector_setConfiguration, METH_VARARGS, NULL}, - { (char *)"FractalDetector_setParams", _wrap_FractalDetector_setParams, METH_VARARGS, NULL}, - { (char *)"FractalDetector_getConfiguration", _wrap_FractalDetector_getConfiguration, METH_VARARGS, NULL}, - { (char *)"FractalDetector_detect", _wrap_FractalDetector_detect, METH_VARARGS, NULL}, - { (char *)"FractalDetector_poseEstimation", _wrap_FractalDetector_poseEstimation, METH_VARARGS, NULL}, - { (char *)"FractalDetector_getRvec", _wrap_FractalDetector_getRvec, METH_VARARGS, NULL}, - { (char *)"FractalDetector_getTvec", _wrap_FractalDetector_getTvec, METH_VARARGS, NULL}, - { (char *)"FractalDetector_drawMarkers", _wrap_FractalDetector_drawMarkers, METH_VARARGS, NULL}, - { (char *)"FractalDetector_draw2d", _wrap_FractalDetector_draw2d, METH_VARARGS, NULL}, - { (char *)"FractalDetector_draw3d", _wrap_FractalDetector_draw3d, METH_VARARGS, NULL}, - { (char *)"FractalDetector_draw3dCube", _wrap_FractalDetector_draw3dCube, METH_VARARGS, NULL}, - { (char *)"FractalDetector_getMarkers", _wrap_FractalDetector_getMarkers, METH_VARARGS, NULL}, - { (char *)"delete_FractalDetector", _wrap_delete_FractalDetector, METH_VARARGS, NULL}, - { (char *)"FractalDetector_swigregister", FractalDetector_swigregister, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_points_set", _wrap_Marker3DInfo_points_set, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_points_get", _wrap_Marker3DInfo_points_get, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_id_set", _wrap_Marker3DInfo_id_set, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_id_get", _wrap_Marker3DInfo_id_get, METH_VARARGS, NULL}, - { (char *)"new_Marker3DInfo", _wrap_new_Marker3DInfo, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo___eq__", _wrap_Marker3DInfo___eq__, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_getMarkerSize", _wrap_Marker3DInfo_getMarkerSize, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_at", _wrap_Marker3DInfo_at, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_push_back", _wrap_Marker3DInfo_push_back, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_size", _wrap_Marker3DInfo_size, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_toStream", _wrap_Marker3DInfo_toStream, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_fromStream", _wrap_Marker3DInfo_fromStream, METH_VARARGS, NULL}, - { (char *)"delete_Marker3DInfo", _wrap_delete_Marker3DInfo, METH_VARARGS, NULL}, - { (char *)"Marker3DInfo_swigregister", Marker3DInfo_swigregister, METH_VARARGS, NULL}, - { (char *)"new_MarkerMap", _wrap_new_MarkerMap, METH_VARARGS, NULL}, - { (char *)"MarkerMap_isExpressedInMeters", _wrap_MarkerMap_isExpressedInMeters, METH_VARARGS, NULL}, - { (char *)"MarkerMap_isExpressedInPixels", _wrap_MarkerMap_isExpressedInPixels, METH_VARARGS, NULL}, - { (char *)"MarkerMap_convertToMeters", _wrap_MarkerMap_convertToMeters, METH_VARARGS, NULL}, - { (char *)"MarkerMap_getIndices", _wrap_MarkerMap_getIndices, METH_VARARGS, NULL}, - { (char *)"MarkerMap_getMarker3DInfo", _wrap_MarkerMap_getMarker3DInfo, METH_VARARGS, NULL}, - { (char *)"MarkerMap_getIndexOfMarkerId", _wrap_MarkerMap_getIndexOfMarkerId, METH_VARARGS, NULL}, - { (char *)"MarkerMap_getIdList", _wrap_MarkerMap_getIdList, METH_VARARGS, NULL}, - { (char *)"MarkerMap_getImage", _wrap_MarkerMap_getImage, METH_VARARGS, NULL}, - { (char *)"MarkerMap_saveToFile", _wrap_MarkerMap_saveToFile, METH_VARARGS, NULL}, - { (char *)"MarkerMap_readFromFile", _wrap_MarkerMap_readFromFile, METH_VARARGS, NULL}, - { (char *)"MarkerMap_calculateExtrinsics", _wrap_MarkerMap_calculateExtrinsics, METH_VARARGS, NULL}, - { (char *)"MarkerMap_getDictionary", _wrap_MarkerMap_getDictionary, METH_VARARGS, NULL}, - { (char *)"MarkerMap_setDictionary", _wrap_MarkerMap_setDictionary, METH_VARARGS, NULL}, - { (char *)"MarkerMap_mInfoType_set", _wrap_MarkerMap_mInfoType_set, METH_VARARGS, NULL}, - { (char *)"MarkerMap_mInfoType_get", _wrap_MarkerMap_mInfoType_get, METH_VARARGS, NULL}, - { (char *)"MarkerMap_toStream", _wrap_MarkerMap_toStream, METH_VARARGS, NULL}, - { (char *)"MarkerMap_fromStream", _wrap_MarkerMap_fromStream, METH_VARARGS, NULL}, - { (char *)"delete_MarkerMap", _wrap_delete_MarkerMap, METH_VARARGS, NULL}, - { (char *)"MarkerMap_swigregister", MarkerMap_swigregister, METH_VARARGS, NULL}, - { (char *)"MarkerPoseTracker_estimatePose", _wrap_MarkerPoseTracker_estimatePose, METH_VARARGS, NULL}, - { (char *)"MarkerPoseTracker_getRTMatrix", _wrap_MarkerPoseTracker_getRTMatrix, METH_VARARGS, NULL}, - { (char *)"MarkerPoseTracker_getRvec", _wrap_MarkerPoseTracker_getRvec, METH_VARARGS, NULL}, - { (char *)"MarkerPoseTracker_getTvec", _wrap_MarkerPoseTracker_getTvec, METH_VARARGS, NULL}, - { (char *)"new_MarkerPoseTracker", _wrap_new_MarkerPoseTracker, METH_VARARGS, NULL}, - { (char *)"delete_MarkerPoseTracker", _wrap_delete_MarkerPoseTracker, METH_VARARGS, NULL}, - { (char *)"MarkerPoseTracker_swigregister", MarkerPoseTracker_swigregister, METH_VARARGS, NULL}, - { (char *)"new_MarkerMapPoseTracker", _wrap_new_MarkerMapPoseTracker, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_setParams", _wrap_MarkerMapPoseTracker_setParams, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_isValid", _wrap_MarkerMapPoseTracker_isValid, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_reset", _wrap_MarkerMapPoseTracker_reset, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_estimatePose", _wrap_MarkerMapPoseTracker_estimatePose, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_getRTMatrix", _wrap_MarkerMapPoseTracker_getRTMatrix, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_getRvec", _wrap_MarkerMapPoseTracker_getRvec, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_getTvec", _wrap_MarkerMapPoseTracker_getTvec, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_setMaxTrackingDifference", _wrap_MarkerMapPoseTracker_setMaxTrackingDifference, METH_VARARGS, NULL}, - { (char *)"delete_MarkerMapPoseTracker", _wrap_delete_MarkerMapPoseTracker, METH_VARARGS, NULL}, - { (char *)"MarkerMapPoseTracker_swigregister", MarkerMapPoseTracker_swigregister, METH_VARARGS, NULL}, - { (char *)"PicoFlann_KeyPointAdapter___call__", _wrap_PicoFlann_KeyPointAdapter___call__, METH_VARARGS, NULL}, - { (char *)"new_PicoFlann_KeyPointAdapter", _wrap_new_PicoFlann_KeyPointAdapter, METH_VARARGS, NULL}, - { (char *)"delete_PicoFlann_KeyPointAdapter", _wrap_delete_PicoFlann_KeyPointAdapter, METH_VARARGS, NULL}, - { (char *)"PicoFlann_KeyPointAdapter_swigregister", PicoFlann_KeyPointAdapter_swigregister, METH_VARARGS, NULL}, - { (char *)"new_FractalPoseTracker", _wrap_new_FractalPoseTracker, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_setParams", _wrap_FractalPoseTracker_setParams, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_fractalInnerPose", _wrap_FractalPoseTracker_fractalInnerPose, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_ROI", _wrap_FractalPoseTracker_ROI, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_assignClass", _wrap_FractalPoseTracker_assignClass, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_fractal_solve_ransac", _wrap_FractalPoseTracker_fractal_solve_ransac, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_fractalRefinement", _wrap_FractalPoseTracker_fractalRefinement, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_getRvec", _wrap_FractalPoseTracker_getRvec, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_getTvec", _wrap_FractalPoseTracker_getTvec, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_getInner3d", _wrap_FractalPoseTracker_getInner3d, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_isPoseValid", _wrap_FractalPoseTracker_isPoseValid, METH_VARARGS, NULL}, - { (char *)"delete_FractalPoseTracker", _wrap_delete_FractalPoseTracker, METH_VARARGS, NULL}, - { (char *)"FractalPoseTracker_swigregister", FractalPoseTracker_swigregister, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler_create", _wrap_FractalMarkerLabeler_create, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler_setConfiguration", _wrap_FractalMarkerLabeler_setConfiguration, METH_VARARGS, NULL}, - { (char *)"delete_FractalMarkerLabeler", _wrap_delete_FractalMarkerLabeler, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler_getName", _wrap_FractalMarkerLabeler_getName, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler_detect", _wrap_FractalMarkerLabeler_detect, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler_getNSubdivisions", _wrap_FractalMarkerLabeler_getNSubdivisions, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler__fractalMarkerSet_set", _wrap_FractalMarkerLabeler__fractalMarkerSet_set, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler__fractalMarkerSet_get", _wrap_FractalMarkerLabeler__fractalMarkerSet_get, METH_VARARGS, NULL}, - { (char *)"new_FractalMarkerLabeler", _wrap_new_FractalMarkerLabeler, METH_VARARGS, NULL}, - { (char *)"FractalMarkerLabeler_swigregister", FractalMarkerLabeler_swigregister, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_create", _wrap_FractalMarkerSet_create, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_configureMat", _wrap_FractalMarkerSet_configureMat, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_dstMarker", _wrap_FractalMarkerSet_dstMarker, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_dstMarkerToMarker", _wrap_FractalMarkerSet_dstMarkerToMarker, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_dstMarkerToFractalDict", _wrap_FractalMarkerSet_dstMarkerToFractalDict, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet__toStream", _wrap_FractalMarkerSet__toStream, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet__fromStream", _wrap_FractalMarkerSet__fromStream, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_isPredefinedConfigurationString", _wrap_FractalMarkerSet_isPredefinedConfigurationString, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_getTypeString", _wrap_FractalMarkerSet_getTypeString, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_getTypeFromString", _wrap_FractalMarkerSet_getTypeFromString, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_load", _wrap_FractalMarkerSet_load, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_loadPredefined", _wrap_FractalMarkerSet_loadPredefined, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_readFromFile", _wrap_FractalMarkerSet_readFromFile, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_saveToFile", _wrap_FractalMarkerSet_saveToFile, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_fractalMarkerCollection_set", _wrap_FractalMarkerSet_fractalMarkerCollection_set, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_fractalMarkerCollection_get", _wrap_FractalMarkerSet_fractalMarkerCollection_get, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_nbits_fractalMarkerIDs_set", _wrap_FractalMarkerSet_nbits_fractalMarkerIDs_set, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_nbits_fractalMarkerIDs_get", _wrap_FractalMarkerSet_nbits_fractalMarkerIDs_get, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_isExpressedInMeters", _wrap_FractalMarkerSet_isExpressedInMeters, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_isExpressedInPixels", _wrap_FractalMarkerSet_isExpressedInPixels, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_isNormalize", _wrap_FractalMarkerSet_isNormalize, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_normalize", _wrap_FractalMarkerSet_normalize, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_convertToMeters", _wrap_FractalMarkerSet_convertToMeters, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_getConfigurations", _wrap_FractalMarkerSet_getConfigurations, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_getFractalSize", _wrap_FractalMarkerSet_getFractalSize, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_nBits", _wrap_FractalMarkerSet_nBits, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_isFractalMarker", _wrap_FractalMarkerSet_isFractalMarker, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_getInnerCorners", _wrap_FractalMarkerSet_getInnerCorners, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_getFractalMarkerImage", _wrap_FractalMarkerSet_getFractalMarkerImage, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_mInfoType_set", _wrap_FractalMarkerSet_mInfoType_set, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_mInfoType_get", _wrap_FractalMarkerSet_mInfoType_get, METH_VARARGS, NULL}, - { (char *)"new_FractalMarkerSet", _wrap_new_FractalMarkerSet, METH_VARARGS, NULL}, - { (char *)"delete_FractalMarkerSet", _wrap_delete_FractalMarkerSet, METH_VARARGS, NULL}, - { (char *)"FractalMarkerSet_swigregister", FractalMarkerSet_swigregister, METH_VARARGS, NULL}, - { (char *)"new_FractalMarker", _wrap_new_FractalMarker, METH_VARARGS, NULL}, - { (char *)"FractalMarker_addSubFractalMarker", _wrap_FractalMarker_addSubFractalMarker, METH_VARARGS, NULL}, - { (char *)"FractalMarker_getInnerCorners", _wrap_FractalMarker_getInnerCorners, METH_VARARGS, NULL}, - { (char *)"FractalMarker_mat", _wrap_FractalMarker_mat, METH_VARARGS, NULL}, - { (char *)"FractalMarker_mask", _wrap_FractalMarker_mask, METH_VARARGS, NULL}, - { (char *)"FractalMarker_nBits", _wrap_FractalMarker_nBits, METH_VARARGS, NULL}, - { (char *)"FractalMarker_subMarkers", _wrap_FractalMarker_subMarkers, METH_VARARGS, NULL}, - { (char *)"delete_FractalMarker", _wrap_delete_FractalMarker, METH_VARARGS, NULL}, - { (char *)"FractalMarker_swigregister", FractalMarker_swigregister, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_begin_set", _wrap_ScopeTimer_begin_set, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_begin_get", _wrap_ScopeTimer_begin_get, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_end_set", _wrap_ScopeTimer_end_set, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_end_get", _wrap_ScopeTimer_end_get, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_name_set", _wrap_ScopeTimer_name_set, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_name_get", _wrap_ScopeTimer_name_get, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_use_set", _wrap_ScopeTimer_use_set, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_use_get", _wrap_ScopeTimer_use_get, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_sc_set", _wrap_ScopeTimer_sc_set, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_sc_get", _wrap_ScopeTimer_sc_get, METH_VARARGS, NULL}, - { (char *)"new_ScopeTimer", _wrap_new_ScopeTimer, METH_VARARGS, NULL}, - { (char *)"delete_ScopeTimer", _wrap_delete_ScopeTimer, METH_VARARGS, NULL}, - { (char *)"ScopeTimer_swigregister", ScopeTimer_swigregister, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_sc_set", _wrap_ScopedTimerEvents_sc_set, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_sc_get", _wrap_ScopedTimerEvents_sc_get, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_vtimes_set", _wrap_ScopedTimerEvents_vtimes_set, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_vtimes_get", _wrap_ScopedTimerEvents_vtimes_get, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_names_set", _wrap_ScopedTimerEvents_names_set, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_names_get", _wrap_ScopedTimerEvents_names_get, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents__name_set", _wrap_ScopedTimerEvents__name_set, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents__name_get", _wrap_ScopedTimerEvents__name_get, METH_VARARGS, NULL}, - { (char *)"new_ScopedTimerEvents", _wrap_new_ScopedTimerEvents, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_add", _wrap_ScopedTimerEvents_add, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_addspaces", _wrap_ScopedTimerEvents_addspaces, METH_VARARGS, NULL}, - { (char *)"delete_ScopedTimerEvents", _wrap_delete_ScopedTimerEvents, METH_VARARGS, NULL}, - { (char *)"ScopedTimerEvents_swigregister", ScopedTimerEvents_swigregister, METH_VARARGS, NULL}, - { (char *)"Timer__s_set", _wrap_Timer__s_set, METH_VARARGS, NULL}, - { (char *)"Timer__s_get", _wrap_Timer__s_get, METH_VARARGS, NULL}, - { (char *)"Timer_sum_set", _wrap_Timer_sum_set, METH_VARARGS, NULL}, - { (char *)"Timer_sum_get", _wrap_Timer_sum_get, METH_VARARGS, NULL}, - { (char *)"Timer_n_set", _wrap_Timer_n_set, METH_VARARGS, NULL}, - { (char *)"Timer_n_get", _wrap_Timer_n_get, METH_VARARGS, NULL}, - { (char *)"Timer__name_set", _wrap_Timer__name_set, METH_VARARGS, NULL}, - { (char *)"Timer__name_get", _wrap_Timer__name_get, METH_VARARGS, NULL}, - { (char *)"new_Timer", _wrap_new_Timer, METH_VARARGS, NULL}, - { (char *)"Timer_setName", _wrap_Timer_setName, METH_VARARGS, NULL}, - { (char *)"Timer_start", _wrap_Timer_start, METH_VARARGS, NULL}, - { (char *)"Timer_end", _wrap_Timer_end, METH_VARARGS, NULL}, - { (char *)"Timer__print", _wrap_Timer__print, METH_VARARGS, NULL}, - { (char *)"Timer_getAverage", _wrap_Timer_getAverage, METH_VARARGS, NULL}, - { (char *)"delete_Timer", _wrap_delete_Timer, METH_VARARGS, NULL}, - { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL}, - { (char *)"__pf_aruco_methodName", _wrap___pf_aruco_methodName, METH_VARARGS, NULL}, - { NULL, NULL, 0, NULL } -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ - -static void *_p_aruco__FractalMarkerTo_p_aruco__Marker3DInfo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((aruco::Marker3DInfo *) ((aruco::FractalMarker *) x)); -} -static void *_p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((std::vector< cv::Point2f,std::allocator< cv::Point2f > > *) ((aruco::Marker *) x)); -} -static void *_p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *) ((aruco::MarkerMap *) x)); -} -static void *_p_aruco__FractalMarkerLabelerTo_p_aruco__MarkerLabeler(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((aruco::MarkerLabeler *) ((aruco::FractalMarkerLabeler *) x)); -} -static swig_type_info _swigt__p_FractalMarker = {"_p_FractalMarker", "FractalMarker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_FractalMarkerSet = {"_p_FractalMarkerSet", "FractalMarkerSet *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_FractalMarkerSet__CONF_TYPES = {"_p_FractalMarkerSet__CONF_TYPES", "FractalMarkerSet::CONF_TYPES *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_Marker = {"_p_Marker", "Marker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__CameraParameters = {"_p_aruco__CameraParameters", "aruco::CameraParameters *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__CvDrawingUtils = {"_p_aruco__CvDrawingUtils", "aruco::CvDrawingUtils *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__Debug = {"_p_aruco__Debug", "aruco::Debug *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__Dictionary = {"_p_aruco__Dictionary", "aruco::Dictionary *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__FractalDetector = {"_p_aruco__FractalDetector", "aruco::FractalDetector *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__FractalMarker = {"_p_aruco__FractalMarker", "aruco::FractalMarker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__FractalMarkerLabeler = {"_p_aruco__FractalMarkerLabeler", "aruco::FractalMarkerLabeler *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__FractalMarkerSet = {"_p_aruco__FractalMarkerSet", "aruco::FractalMarkerSet *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__FractalPoseTracker = {"_p_aruco__FractalPoseTracker", "aruco::FractalPoseTracker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__Marker = {"_p_aruco__Marker", "std::vector< aruco::Marker,std::allocator< aruco::Marker > >::value_type *|aruco::MarkerCandidate *|aruco::Marker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__Marker3DInfo = {"_p_aruco__Marker3DInfo", "aruco::Marker3DInfo *|std::vector< aruco::Marker3DInfo >::value_type *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__MarkerDetector = {"_p_aruco__MarkerDetector", "aruco::MarkerDetector *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__MarkerDetector__Params = {"_p_aruco__MarkerDetector__Params", "aruco::MarkerDetector::Params *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__MarkerLabeler = {"_p_aruco__MarkerLabeler", "aruco::MarkerLabeler *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__MarkerMap = {"_p_aruco__MarkerMap", "aruco::MarkerMap *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__MarkerMapPoseTracker = {"_p_aruco__MarkerMapPoseTracker", "aruco::MarkerMapPoseTracker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__MarkerPoseTracker = {"_p_aruco__MarkerPoseTracker", "aruco::MarkerPoseTracker *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__PicoFlann_KeyPointAdapter = {"_p_aruco__PicoFlann_KeyPointAdapter", "aruco::PicoFlann_KeyPointAdapter *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__ScopeTimer = {"_p_aruco__ScopeTimer", "aruco::ScopeTimer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__ScopedTimerEvents = {"_p_aruco__ScopedTimerEvents", "aruco::ScopedTimerEvents *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_aruco__Timer = {"_p_aruco__Timer", "aruco::Timer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__FileStorage = {"_p_cv__FileStorage", "cv::FileStorage *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__KeyPoint = {"_p_cv__KeyPoint", "cv::KeyPoint *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__Point2f = {"_p_cv__Point2f", "std::vector< cv::Point2f >::value_type *|cv::Point2f *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__Point3f = {"_p_cv__Point3f", "cv::Point3f *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__PtrT_aruco__FractalMarkerLabeler_t = {"_p_cv__PtrT_aruco__FractalMarkerLabeler_t", "cv::Ptr< aruco::FractalMarkerLabeler > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__PtrT_aruco__MarkerDetector_t = {"_p_cv__PtrT_aruco__MarkerDetector_t", "cv::Ptr< aruco::MarkerDetector > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__PtrT_aruco__MarkerLabeler_t = {"_p_cv__PtrT_aruco__MarkerLabeler_t", "cv::Ptr< aruco::MarkerLabeler > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_cv__Size = {"_p_cv__Size", "cv::Size *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__allocatorT_aruco__Marker3DInfo_t = {"_p_std__allocatorT_aruco__Marker3DInfo_t", "std::vector< aruco::Marker3DInfo >::allocator_type *|std::allocator< aruco::Marker3DInfo > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__allocatorT_aruco__Marker_t = {"_p_std__allocatorT_aruco__Marker_t", "std::allocator< aruco::Marker > *|std::vector< aruco::Marker,std::allocator< aruco::Marker > >::allocator_type *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__allocatorT_cv__Point2f_t = {"_p_std__allocatorT_cv__Point2f_t", "std::vector< cv::Point2f >::allocator_type *|std::allocator< cv::Point2f > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__chrono__high_resolution_clock__time_point = {"_p_std__chrono__high_resolution_clock__time_point", "std::chrono::high_resolution_clock::time_point *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_int_FractalMarker_t = {"_p_std__mapT_int_FractalMarker_t", "std::map< int,FractalMarker > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t = {"_p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t", "std::map< int,std::vector< cv::Point3f,std::allocator< cv::Point3f > > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t", "std::map< int,std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_uint64_t_uint16_t_t = {"_p_std__mapT_uint64_t_uint16_t_t", "std::map< uint64_t,uint16_t > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__pairT_cv__Mat_cv__Mat_t = {"_p_std__pairT_cv__Mat_cv__Mat_t", "std::pair< cv::Mat,cv::Mat > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t = {"_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t", "std::vector< aruco::Marker3DInfo,std::allocator< aruco::Marker3DInfo > > *|std::vector< aruco::Marker3DInfo > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t = {"_p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t", "std::vector< aruco::Marker,std::allocator< aruco::Marker > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t = {"_p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t", "std::vector< cv::KeyPoint,std::allocator< cv::KeyPoint > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t = {"_p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t", "std::vector< cv::Mat,std::allocator< cv::Mat > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t = {"_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t", "std::vector< cv::Point2f > *|std::vector< cv::Point2f,std::allocator< cv::Point2f > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t = {"_p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t", "std::vector< cv::Point3f,std::allocator< cv::Point3f > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t = {"_p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t", "std::vector< std::chrono::high_resolution_clock::time_point,std::allocator< std::chrono::high_resolution_clock::time_point > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t = {"_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t", "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t = {"_p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t", "std::vector< std::pair< uint,std::vector< uint,std::allocator< uint > > >,std::allocator< std::pair< uint,std::vector< uint,std::allocator< uint > > > > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t = {"_p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t", "std::vector< std::vector< cv::Point2f,std::allocator< cv::Point2f > >,std::allocator< std::vector< cv::Point2f,std::allocator< cv::Point2f > > > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_vectorT_aruco__Marker_t = {"_p_vectorT_aruco__Marker_t", "vector< aruco::Marker > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_vectorT_cv__Point3f_t = {"_p_vectorT_cv__Point3f_t", "vector< cv::Point3f > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_vectorT_cv__Point_t = {"_p_vectorT_cv__Point_t", "vector< cv::Point > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_vectorT_int_t = {"_p_vectorT_int_t", "vector< int > *", 0, 0, (void*)0, 0}; - -static swig_type_info *swig_type_initial[] = { - &_swigt__p_FractalMarker, - &_swigt__p_FractalMarkerSet, - &_swigt__p_FractalMarkerSet__CONF_TYPES, - &_swigt__p_Marker, - &_swigt__p_allocator_type, - &_swigt__p_aruco__CameraParameters, - &_swigt__p_aruco__CvDrawingUtils, - &_swigt__p_aruco__Debug, - &_swigt__p_aruco__Dictionary, - &_swigt__p_aruco__FractalDetector, - &_swigt__p_aruco__FractalMarker, - &_swigt__p_aruco__FractalMarkerLabeler, - &_swigt__p_aruco__FractalMarkerSet, - &_swigt__p_aruco__FractalPoseTracker, - &_swigt__p_aruco__Marker, - &_swigt__p_aruco__Marker3DInfo, - &_swigt__p_aruco__MarkerDetector, - &_swigt__p_aruco__MarkerDetector__Params, - &_swigt__p_aruco__MarkerLabeler, - &_swigt__p_aruco__MarkerMap, - &_swigt__p_aruco__MarkerMapPoseTracker, - &_swigt__p_aruco__MarkerPoseTracker, - &_swigt__p_aruco__PicoFlann_KeyPointAdapter, - &_swigt__p_aruco__ScopeTimer, - &_swigt__p_aruco__ScopedTimerEvents, - &_swigt__p_aruco__Timer, - &_swigt__p_char, - &_swigt__p_cv__FileStorage, - &_swigt__p_cv__KeyPoint, - &_swigt__p_cv__Point2f, - &_swigt__p_cv__Point3f, - &_swigt__p_cv__PtrT_aruco__FractalMarkerLabeler_t, - &_swigt__p_cv__PtrT_aruco__MarkerDetector_t, - &_swigt__p_cv__PtrT_aruco__MarkerLabeler_t, - &_swigt__p_cv__Size, - &_swigt__p_difference_type, - &_swigt__p_double, - &_swigt__p_float, - &_swigt__p_int, - &_swigt__p_p_PyObject, - &_swigt__p_size_type, - &_swigt__p_std__allocatorT_aruco__Marker3DInfo_t, - &_swigt__p_std__allocatorT_aruco__Marker_t, - &_swigt__p_std__allocatorT_cv__Point2f_t, - &_swigt__p_std__allocatorT_int_t, - &_swigt__p_std__chrono__high_resolution_clock__time_point, - &_swigt__p_std__invalid_argument, - &_swigt__p_std__istream, - &_swigt__p_std__mapT_int_FractalMarker_t, - &_swigt__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, - &_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, - &_swigt__p_std__mapT_uint64_t_uint16_t_t, - &_swigt__p_std__ostream, - &_swigt__p_std__pairT_cv__Mat_cv__Mat_t, - &_swigt__p_std__string, - &_swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, - &_swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, - &_swigt__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, - &_swigt__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, - &_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, - &_swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, - &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, - &_swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, - &_swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, - &_swigt__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, - &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, - &_swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, - &_swigt__p_swig__SwigPyIterator, - &_swigt__p_uint32_t, - &_swigt__p_uint64_t, - &_swigt__p_value_type, - &_swigt__p_vectorT_aruco__Marker_t, - &_swigt__p_vectorT_cv__Point3f_t, - &_swigt__p_vectorT_cv__Point_t, - &_swigt__p_vectorT_int_t, -}; - -static swig_cast_info _swigc__p_FractalMarker[] = { {&_swigt__p_FractalMarker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_FractalMarkerSet[] = { {&_swigt__p_FractalMarkerSet, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_FractalMarkerSet__CONF_TYPES[] = { {&_swigt__p_FractalMarkerSet__CONF_TYPES, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_Marker[] = { {&_swigt__p_Marker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__CameraParameters[] = { {&_swigt__p_aruco__CameraParameters, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__CvDrawingUtils[] = { {&_swigt__p_aruco__CvDrawingUtils, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Debug[] = { {&_swigt__p_aruco__Debug, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Dictionary[] = { {&_swigt__p_aruco__Dictionary, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__FractalDetector[] = { {&_swigt__p_aruco__FractalDetector, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__FractalMarker[] = { {&_swigt__p_aruco__FractalMarker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__FractalMarkerLabeler[] = { {&_swigt__p_aruco__FractalMarkerLabeler, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__FractalMarkerSet[] = { {&_swigt__p_aruco__FractalMarkerSet, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__FractalPoseTracker[] = { {&_swigt__p_aruco__FractalPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Marker[] = { {&_swigt__p_aruco__Marker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Marker3DInfo[] = { {&_swigt__p_aruco__FractalMarker, _p_aruco__FractalMarkerTo_p_aruco__Marker3DInfo, 0, 0}, {&_swigt__p_aruco__Marker3DInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerDetector[] = { {&_swigt__p_aruco__MarkerDetector, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerDetector__Params[] = { {&_swigt__p_aruco__MarkerDetector__Params, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerLabeler[] = { {&_swigt__p_aruco__MarkerLabeler, 0, 0, 0}, {&_swigt__p_aruco__FractalMarkerLabeler, _p_aruco__FractalMarkerLabelerTo_p_aruco__MarkerLabeler, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerMap[] = { {&_swigt__p_aruco__MarkerMap, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerMapPoseTracker[] = { {&_swigt__p_aruco__MarkerMapPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__MarkerPoseTracker[] = { {&_swigt__p_aruco__MarkerPoseTracker, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__PicoFlann_KeyPointAdapter[] = { {&_swigt__p_aruco__PicoFlann_KeyPointAdapter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__ScopeTimer[] = { {&_swigt__p_aruco__ScopeTimer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__ScopedTimerEvents[] = { {&_swigt__p_aruco__ScopedTimerEvents, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_aruco__Timer[] = { {&_swigt__p_aruco__Timer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__FileStorage[] = { {&_swigt__p_cv__FileStorage, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__KeyPoint[] = { {&_swigt__p_cv__KeyPoint, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__Point2f[] = { {&_swigt__p_cv__Point2f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__Point3f[] = { {&_swigt__p_cv__Point3f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__PtrT_aruco__FractalMarkerLabeler_t[] = { {&_swigt__p_cv__PtrT_aruco__FractalMarkerLabeler_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__PtrT_aruco__MarkerDetector_t[] = { {&_swigt__p_cv__PtrT_aruco__MarkerDetector_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__PtrT_aruco__MarkerLabeler_t[] = { {&_swigt__p_cv__PtrT_aruco__MarkerLabeler_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_cv__Size[] = { {&_swigt__p_cv__Size, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__allocatorT_aruco__Marker3DInfo_t[] = { {&_swigt__p_std__allocatorT_aruco__Marker3DInfo_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__allocatorT_aruco__Marker_t[] = { {&_swigt__p_std__allocatorT_aruco__Marker_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__allocatorT_cv__Point2f_t[] = { {&_swigt__p_std__allocatorT_cv__Point2f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__allocatorT_int_t[] = { {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__chrono__high_resolution_clock__time_point[] = { {&_swigt__p_std__chrono__high_resolution_clock__time_point, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_int_FractalMarker_t[] = { {&_swigt__p_std__mapT_int_FractalMarker_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t[] = { {&_swigt__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_uint64_t_uint16_t_t[] = { {&_swigt__p_std__mapT_uint64_t_uint16_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__pairT_cv__Mat_cv__Mat_t[] = { {&_swigt__p_std__pairT_cv__Mat_cv__Mat_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0, 0}, {&_swigt__p_aruco__MarkerMap, _p_aruco__MarkerMapTo_p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t[] = { {&_swigt__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t[] = { {&_swigt__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t[] = { {&_swigt__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t[] = { {&_swigt__p_aruco__Marker, _p_aruco__MarkerTo_p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0}, {&_swigt__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t[] = { {&_swigt__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t[] = { {&_swigt__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t[] = { {&_swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = { {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_uint64_t[] = { {&_swigt__p_uint64_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_vectorT_aruco__Marker_t[] = { {&_swigt__p_vectorT_aruco__Marker_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_vectorT_cv__Point3f_t[] = { {&_swigt__p_vectorT_cv__Point3f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_vectorT_cv__Point_t[] = { {&_swigt__p_vectorT_cv__Point_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_vectorT_int_t[] = { {&_swigt__p_vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; - -static swig_cast_info *swig_cast_initial[] = { - _swigc__p_FractalMarker, - _swigc__p_FractalMarkerSet, - _swigc__p_FractalMarkerSet__CONF_TYPES, - _swigc__p_Marker, - _swigc__p_allocator_type, - _swigc__p_aruco__CameraParameters, - _swigc__p_aruco__CvDrawingUtils, - _swigc__p_aruco__Debug, - _swigc__p_aruco__Dictionary, - _swigc__p_aruco__FractalDetector, - _swigc__p_aruco__FractalMarker, - _swigc__p_aruco__FractalMarkerLabeler, - _swigc__p_aruco__FractalMarkerSet, - _swigc__p_aruco__FractalPoseTracker, - _swigc__p_aruco__Marker, - _swigc__p_aruco__Marker3DInfo, - _swigc__p_aruco__MarkerDetector, - _swigc__p_aruco__MarkerDetector__Params, - _swigc__p_aruco__MarkerLabeler, - _swigc__p_aruco__MarkerMap, - _swigc__p_aruco__MarkerMapPoseTracker, - _swigc__p_aruco__MarkerPoseTracker, - _swigc__p_aruco__PicoFlann_KeyPointAdapter, - _swigc__p_aruco__ScopeTimer, - _swigc__p_aruco__ScopedTimerEvents, - _swigc__p_aruco__Timer, - _swigc__p_char, - _swigc__p_cv__FileStorage, - _swigc__p_cv__KeyPoint, - _swigc__p_cv__Point2f, - _swigc__p_cv__Point3f, - _swigc__p_cv__PtrT_aruco__FractalMarkerLabeler_t, - _swigc__p_cv__PtrT_aruco__MarkerDetector_t, - _swigc__p_cv__PtrT_aruco__MarkerLabeler_t, - _swigc__p_cv__Size, - _swigc__p_difference_type, - _swigc__p_double, - _swigc__p_float, - _swigc__p_int, - _swigc__p_p_PyObject, - _swigc__p_size_type, - _swigc__p_std__allocatorT_aruco__Marker3DInfo_t, - _swigc__p_std__allocatorT_aruco__Marker_t, - _swigc__p_std__allocatorT_cv__Point2f_t, - _swigc__p_std__allocatorT_int_t, - _swigc__p_std__chrono__high_resolution_clock__time_point, - _swigc__p_std__invalid_argument, - _swigc__p_std__istream, - _swigc__p_std__mapT_int_FractalMarker_t, - _swigc__p_std__mapT_int_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t_t, - _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_t, - _swigc__p_std__mapT_uint64_t_uint16_t_t, - _swigc__p_std__ostream, - _swigc__p_std__pairT_cv__Mat_cv__Mat_t, - _swigc__p_std__string, - _swigc__p_std__vectorT_aruco__Marker3DInfo_std__allocatorT_aruco__Marker3DInfo_t_t, - _swigc__p_std__vectorT_aruco__Marker_std__allocatorT_aruco__Marker_t_t, - _swigc__p_std__vectorT_cv__KeyPoint_std__allocatorT_cv__KeyPoint_t_t, - _swigc__p_std__vectorT_cv__Mat_std__allocatorT_cv__Mat_t_t, - _swigc__p_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t, - _swigc__p_std__vectorT_cv__Point3f_std__allocatorT_cv__Point3f_t_t, - _swigc__p_std__vectorT_int_std__allocatorT_int_t_t, - _swigc__p_std__vectorT_std__chrono__high_resolution_clock__time_point_std__allocatorT_std__chrono__high_resolution_clock__time_point_t_t, - _swigc__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, - _swigc__p_std__vectorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_std__allocatorT_std__pairT_uint_std__vectorT_uint_std__allocatorT_uint_t_t_t_t_t, - _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, - _swigc__p_std__vectorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_std__allocatorT_std__vectorT_cv__Point2f_std__allocatorT_cv__Point2f_t_t_t_t, - _swigc__p_swig__SwigPyIterator, - _swigc__p_uint32_t, - _swigc__p_uint64_t, - _swigc__p_value_type, - _swigc__p_vectorT_aruco__Marker_t, - _swigc__p_vectorT_cv__Point3f_t, - _swigc__p_vectorT_cv__Point_t, - _swigc__p_vectorT_int_t, -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ - -static swig_const_info swig_const_table[] = { -{0, 0, 0, 0.0, 0, 0}}; - -#ifdef __cplusplus -} -#endif -/* ----------------------------------------------------------------------------- - * Type initialization: - * This problem is tough by the requirement that no dynamic - * memory is used. Also, since swig_type_info structures store pointers to - * swig_cast_info structures and swig_cast_info structures store pointers back - * to swig_type_info structures, we need some lookup code at initialization. - * The idea is that swig generates all the structures that are needed. - * The runtime then collects these partially filled structures. - * The SWIG_InitializeModule function takes these initial arrays out of - * swig_module, and does all the lookup, filling in the swig_module.types - * array with the correct data and linking the correct swig_cast_info - * structures together. - * - * The generated swig_type_info structures are assigned statically to an initial - * array. We just loop through that array, and handle each type individually. - * First we lookup if this type has been already loaded, and if so, use the - * loaded structure instead of the generated one. Then we have to fill in the - * cast linked list. The cast data is initially stored in something like a - * two-dimensional array. Each row corresponds to a type (there are the same - * number of rows as there are in the swig_type_initial array). Each entry in - * a column is one of the swig_cast_info structures for that type. - * The cast_initial array is actually an array of arrays, because each row has - * a variable number of columns. So to actually build the cast linked list, - * we find the array of casts associated with the type, and loop through it - * adding the casts to the list. The one last trick we need to do is making - * sure the type pointer in the swig_cast_info struct is correct. - * - * First off, we lookup the cast->type name to see if it is already loaded. - * There are three cases to handle: - * 1) If the cast->type has already been loaded AND the type we are adding - * casting info to has not been loaded (it is in this module), THEN we - * replace the cast->type pointer with the type pointer that has already - * been loaded. - * 2) If BOTH types (the one we are adding casting info to, and the - * cast->type) are loaded, THEN the cast info has already been loaded by - * the previous module so we just ignore it. - * 3) Finally, if cast->type has not already been loaded, then we add that - * swig_cast_info to the linked list (because the cast->type) pointer will - * be correct. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#if 0 -} /* c-mode */ -#endif -#endif - -#if 0 -#define SWIGRUNTIME_DEBUG -#endif - - -SWIGRUNTIME void -SWIG_InitializeModule(void *clientdata) { - size_t i; - swig_module_info *module_head, *iter; - int init; - - /* check to see if the circular list has been setup, if not, set it up */ - if (swig_module.next==0) { - /* Initialize the swig_module */ - swig_module.type_initial = swig_type_initial; - swig_module.cast_initial = swig_cast_initial; - swig_module.next = &swig_module; - init = 1; - } else { - init = 0; - } - - /* Try and load any already created modules */ - module_head = SWIG_GetModule(clientdata); - if (!module_head) { - /* This is the first module loaded for this interpreter */ - /* so set the swig module into the interpreter */ - SWIG_SetModule(clientdata, &swig_module); - } else { - /* the interpreter has loaded a SWIG module, but has it loaded this one? */ - iter=module_head; - do { - if (iter==&swig_module) { - /* Our module is already in the list, so there's nothing more to do. */ - return; - } - iter=iter->next; - } while (iter!= module_head); - - /* otherwise we must add our module into the list */ - swig_module.next = module_head->next; - module_head->next = &swig_module; - } - - /* When multiple interpreters are used, a module could have already been initialized in - a different interpreter, but not yet have a pointer in this interpreter. - In this case, we do not want to continue adding types... everything should be - set up already */ - if (init == 0) return; - - /* Now work on filling in swig_module.types */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: size %d\n", swig_module.size); -#endif - for (i = 0; i < swig_module.size; ++i) { - swig_type_info *type = 0; - swig_type_info *ret; - swig_cast_info *cast; - -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); -#endif - - /* if there is another module already loaded */ - if (swig_module.next != &swig_module) { - type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); - } - if (type) { - /* Overwrite clientdata field */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found type %s\n", type->name); -#endif - if (swig_module.type_initial[i]->clientdata) { - type->clientdata = swig_module.type_initial[i]->clientdata; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); -#endif - } - } else { - type = swig_module.type_initial[i]; - } - - /* Insert casting types */ - cast = swig_module.cast_initial[i]; - while (cast->type) { - /* Don't need to add information already in the list */ - ret = 0; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); -#endif - if (swig_module.next != &swig_module) { - ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); -#ifdef SWIGRUNTIME_DEBUG - if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); -#endif - } - if (ret) { - if (type == swig_module.type_initial[i]) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: skip old type %s\n", ret->name); -#endif - cast->type = ret; - ret = 0; - } else { - /* Check for casting already in the list */ - swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); -#ifdef SWIGRUNTIME_DEBUG - if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); -#endif - if (!ocast) ret = 0; - } - } - - if (!ret) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); -#endif - if (type->cast) { - type->cast->prev = cast; - cast->next = type->cast; - } - type->cast = cast; - } - cast++; - } - /* Set entry in modules->types array equal to the type */ - swig_module.types[i] = type; - } - swig_module.types[i] = 0; - -#ifdef SWIGRUNTIME_DEBUG - printf("**** SWIG_InitializeModule: Cast List ******\n"); - for (i = 0; i < swig_module.size; ++i) { - int j = 0; - swig_cast_info *cast = swig_module.cast_initial[i]; - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); - while (cast->type) { - printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); - cast++; - ++j; - } - printf("---- Total casts: %d\n",j); - } - printf("**** SWIG_InitializeModule: Cast List ******\n"); -#endif -} - -/* This function will propagate the clientdata field of type to -* any new swig_type_info structures that have been added into the list -* of equivalent types. It is like calling -* SWIG_TypeClientData(type, clientdata) a second time. -*/ -SWIGRUNTIME void -SWIG_PropagateClientData(void) { - size_t i; - swig_cast_info *equiv; - static int init_run = 0; - - if (init_run) return; - init_run = 1; - - for (i = 0; i < swig_module.size; i++) { - if (swig_module.types[i]->clientdata) { - equiv = swig_module.types[i]->cast; - while (equiv) { - if (!equiv->converter) { - if (equiv->type && !equiv->type->clientdata) - SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); - } - equiv = equiv->next; - } - } - } -} - -#ifdef __cplusplus -#if 0 -{ - /* c-mode */ -#endif -} -#endif - - - -#ifdef __cplusplus -extern "C" { -#endif - - /* Python-specific SWIG API */ -#define SWIG_newvarlink() SWIG_Python_newvarlink() -#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) -#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) - - /* ----------------------------------------------------------------------------- - * global variable support code. - * ----------------------------------------------------------------------------- */ - - typedef struct swig_globalvar { - char *name; /* Name of global variable */ - PyObject *(*get_attr)(void); /* Return the current value */ - int (*set_attr)(PyObject *); /* Set the value */ - struct swig_globalvar *next; - } swig_globalvar; - - typedef struct swig_varlinkobject { - PyObject_HEAD - swig_globalvar *vars; - } swig_varlinkobject; - - SWIGINTERN PyObject * - swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { -#if PY_VERSION_HEX >= 0x03000000 - return PyUnicode_InternFromString(""); -#else - return PyString_FromString(""); -#endif - } - - SWIGINTERN PyObject * - swig_varlink_str(swig_varlinkobject *v) { -#if PY_VERSION_HEX >= 0x03000000 - PyObject *str = PyUnicode_InternFromString("("); - PyObject *tail; - PyObject *joined; - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - tail = PyUnicode_FromString(var->name); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - if (var->next) { - tail = PyUnicode_InternFromString(", "); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - } - } - tail = PyUnicode_InternFromString(")"); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; -#else - PyObject *str = PyString_FromString("("); - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - PyString_ConcatAndDel(&str,PyString_FromString(var->name)); - if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); - } - PyString_ConcatAndDel(&str,PyString_FromString(")")); -#endif - return str; - } - - SWIGINTERN int - swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { - char *tmp; - PyObject *str = swig_varlink_str(v); - fprintf(fp,"Swig global variables "); - fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(str); - return 0; - } - - SWIGINTERN void - swig_varlink_dealloc(swig_varlinkobject *v) { - swig_globalvar *var = v->vars; - while (var) { - swig_globalvar *n = var->next; - free(var->name); - free(var); - var = n; - } - } - - SWIGINTERN PyObject * - swig_varlink_getattr(swig_varlinkobject *v, char *n) { - PyObject *res = NULL; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->get_attr)(); - break; - } - var = var->next; - } - if (res == NULL && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } - - SWIGINTERN int - swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { - int res = 1; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->set_attr)(p); - break; - } - var = var->next; - } - if (res == 1 && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } - - SWIGINTERN PyTypeObject* - swig_varlink_type(void) { - static char varlink__doc__[] = "Swig var link object"; - static PyTypeObject varlink_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { -#if PY_VERSION_HEX >= 0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) -#else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ -#endif - (char *)"swigvarlink", /* tp_name */ - sizeof(swig_varlinkobject), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor) swig_varlink_dealloc, /* tp_dealloc */ - (printfunc) swig_varlink_print, /* tp_print */ - (getattrfunc) swig_varlink_getattr, /* tp_getattr */ - (setattrfunc) swig_varlink_setattr, /* tp_setattr */ - 0, /* tp_compare */ - (reprfunc) swig_varlink_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - (reprfunc) swig_varlink_str, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - 0, /* tp_flags */ - varlink__doc__, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ -#if PY_VERSION_HEX >= 0x02020000 - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ -#endif -#if PY_VERSION_HEX >= 0x02030000 - 0, /* tp_del */ -#endif -#if PY_VERSION_HEX >= 0x02060000 - 0, /* tp_version_tag */ -#endif -#if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ -#endif -#ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ -#if PY_VERSION_HEX >= 0x02050000 - 0, /* tp_prev */ -#endif - 0 /* tp_next */ -#endif - }; - varlink_type = tmp; - type_init = 1; -#if PY_VERSION_HEX < 0x02020000 - varlink_type.ob_type = &PyType_Type; -#else - if (PyType_Ready(&varlink_type) < 0) - return NULL; -#endif - } - return &varlink_type; - } - - /* Create a variable linking object for use later */ - SWIGINTERN PyObject * - SWIG_Python_newvarlink(void) { - swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); - if (result) { - result->vars = 0; - } - return ((PyObject*) result); - } - - SWIGINTERN void - SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { - swig_varlinkobject *v = (swig_varlinkobject *) p; - swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); - if (gv) { - size_t size = strlen(name)+1; - gv->name = (char *)malloc(size); - if (gv->name) { - strncpy(gv->name,name,size); - gv->get_attr = get_attr; - gv->set_attr = set_attr; - gv->next = v->vars; - } - } - v->vars = gv; - } - - SWIGINTERN PyObject * - SWIG_globals(void) { - static PyObject *_SWIG_globals = 0; - if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); - return _SWIG_globals; - } - - /* ----------------------------------------------------------------------------- - * constants/methods manipulation - * ----------------------------------------------------------------------------- */ - - /* Install Constants */ - SWIGINTERN void - SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { - PyObject *obj = 0; - size_t i; - for (i = 0; constants[i].type; ++i) { - switch(constants[i].type) { - case SWIG_PY_POINTER: - obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); - break; - case SWIG_PY_BINARY: - obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); - break; - default: - obj = 0; - break; - } - if (obj) { - PyDict_SetItemString(d, constants[i].name, obj); - Py_DECREF(obj); - } - } - } - - /* -----------------------------------------------------------------------------*/ - /* Fix SwigMethods to carry the callback ptrs when needed */ - /* -----------------------------------------------------------------------------*/ - - SWIGINTERN void - SWIG_Python_FixMethods(PyMethodDef *methods, - swig_const_info *const_table, - swig_type_info **types, - swig_type_info **types_initial) { - size_t i; - for (i = 0; methods[i].ml_name; ++i) { - const char *c = methods[i].ml_doc; - if (!c) continue; - c = strstr(c, "swig_ptr: "); - if (c) { - int j; - swig_const_info *ci = 0; - const char *name = c + 10; - for (j = 0; const_table[j].type; ++j) { - if (strncmp(const_table[j].name, name, - strlen(const_table[j].name)) == 0) { - ci = &(const_table[j]); - break; - } - } - if (ci) { - void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; - if (ptr) { - size_t shift = (ci->ptype) - types; - swig_type_info *ty = types_initial[shift]; - size_t ldoc = (c - methods[i].ml_doc); - size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; - char *ndoc = (char*)malloc(ldoc + lptr + 10); - if (ndoc) { - char *buff = ndoc; - strncpy(buff, methods[i].ml_doc, ldoc); - buff += ldoc; - strncpy(buff, "swig_ptr: ", 10); - buff += 10; - SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); - methods[i].ml_doc = ndoc; - } - } - } - } - } - } - -#ifdef __cplusplus -} -#endif - -/* -----------------------------------------------------------------------------* - * Partial Init method - * -----------------------------------------------------------------------------*/ - -#ifdef __cplusplus -extern "C" -#endif - -SWIGEXPORT -#if PY_VERSION_HEX >= 0x03000000 -PyObject* -#else -void -#endif -SWIG_init(void) { - PyObject *m, *d, *md; -#if PY_VERSION_HEX >= 0x03000000 - static struct PyModuleDef SWIG_module = { -# if PY_VERSION_HEX >= 0x03020000 - PyModuleDef_HEAD_INIT, -# else - { - PyObject_HEAD_INIT(NULL) - NULL, /* m_init */ - 0, /* m_index */ - NULL, /* m_copy */ - }, -# endif - (char *) SWIG_name, - NULL, - -1, - SwigMethods, - NULL, - NULL, - NULL, - NULL - }; -#endif - -#if defined(SWIGPYTHON_BUILTIN) - static SwigPyClientData SwigPyObject_clientdata = { - 0, 0, 0, 0, 0, 0, 0 - }; - static PyGetSetDef this_getset_def = { - (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL - }; - static SwigPyGetSet thisown_getset_closure = { - (PyCFunction) SwigPyObject_own, - (PyCFunction) SwigPyObject_own - }; - static PyGetSetDef thisown_getset_def = { - (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure - }; - PyTypeObject *builtin_pytype; - int builtin_base_count; - swig_type_info *builtin_basetype; - PyObject *tuple; - PyGetSetDescrObject *static_getset; - PyTypeObject *metatype; - PyTypeObject *swigpyobject; - SwigPyClientData *cd; - PyObject *public_interface, *public_symbol; - PyObject *this_descr; - PyObject *thisown_descr; - PyObject *self = 0; - int i; - - (void)builtin_pytype; - (void)builtin_base_count; - (void)builtin_basetype; - (void)tuple; - (void)static_getset; - (void)self; - - /* Metaclass is used to implement static member variables */ - metatype = SwigPyObjectType(); - assert(metatype); -#endif - - /* Fix SwigMethods to carry the callback ptrs when needed */ - SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); - -#if PY_VERSION_HEX >= 0x03000000 - m = PyModule_Create(&SWIG_module); -#else - m = Py_InitModule((char *) SWIG_name, SwigMethods); -#endif - - md = d = PyModule_GetDict(m); - (void)md; - - SWIG_InitializeModule(0); - -#ifdef SWIGPYTHON_BUILTIN - swigpyobject = SwigPyObject_TypeOnce(); - - SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); - assert(SwigPyObject_stype); - cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; - if (!cd) { - SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; - SwigPyObject_clientdata.pytype = swigpyobject; - } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { - PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); -# if PY_VERSION_HEX >= 0x03000000 - return NULL; -# else - return; -# endif - } - - /* All objects have a 'this' attribute */ - this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); - (void)this_descr; - - /* All objects have a 'thisown' attribute */ - thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); - (void)thisown_descr; - - public_interface = PyList_New(0); - public_symbol = 0; - (void)public_symbol; - - PyDict_SetItemString(md, "__all__", public_interface); - Py_DECREF(public_interface); - for (i = 0; SwigMethods[i].ml_name != NULL; ++i) - SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); - for (i = 0; swig_const_table[i].name != 0; ++i) - SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); -#endif - - SWIG_InstallConstants(d,swig_const_table); - - - import_array(); - - SWIG_Python_SetConstant(d, "ARUCO_VERSION_MAJOR",SWIG_From_int(static_cast< int >(3))); - SWIG_Python_SetConstant(d, "ARUCO_VERSION_MINOR",SWIG_From_int(static_cast< int >(0))); - SWIG_Python_SetConstant(d, "Dictionary_ALL_DICTS",SWIG_From_int(static_cast< int >(aruco::Dictionary::ALL_DICTS))); - SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_36h12",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_36h12))); - SWIG_Python_SetConstant(d, "Dictionary_ARUCO",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO))); - SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_25h7",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_25h7))); - SWIG_Python_SetConstant(d, "Dictionary_ARUCO_MIP_16h3",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARUCO_MIP_16h3))); - SWIG_Python_SetConstant(d, "Dictionary_ARTAG",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARTAG))); - SWIG_Python_SetConstant(d, "Dictionary_ARTOOLKITPLUS",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARTOOLKITPLUS))); - SWIG_Python_SetConstant(d, "Dictionary_ARTOOLKITPLUSBCH",SWIG_From_int(static_cast< int >(aruco::Dictionary::ARTOOLKITPLUSBCH))); - SWIG_Python_SetConstant(d, "Dictionary_TAG16h5",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG16h5))); - SWIG_Python_SetConstant(d, "Dictionary_TAG25h7",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG25h7))); - SWIG_Python_SetConstant(d, "Dictionary_TAG25h9",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG25h9))); - SWIG_Python_SetConstant(d, "Dictionary_TAG36h11",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG36h11))); - SWIG_Python_SetConstant(d, "Dictionary_TAG36h10",SWIG_From_int(static_cast< int >(aruco::Dictionary::TAG36h10))); - SWIG_Python_SetConstant(d, "Dictionary_CHILITAGS",SWIG_From_int(static_cast< int >(aruco::Dictionary::CHILITAGS))); - SWIG_Python_SetConstant(d, "Dictionary_CUSTOM",SWIG_From_int(static_cast< int >(aruco::Dictionary::CUSTOM))); - SWIG_Python_SetConstant(d, "DM_NORMAL",SWIG_From_int(static_cast< int >(aruco::DM_NORMAL))); - SWIG_Python_SetConstant(d, "DM_FAST",SWIG_From_int(static_cast< int >(aruco::DM_FAST))); - SWIG_Python_SetConstant(d, "DM_VIDEO_FAST",SWIG_From_int(static_cast< int >(aruco::DM_VIDEO_FAST))); - SWIG_Python_SetConstant(d, "CORNER_SUBPIX",SWIG_From_int(static_cast< int >(aruco::CORNER_SUBPIX))); - SWIG_Python_SetConstant(d, "CORNER_LINES",SWIG_From_int(static_cast< int >(aruco::CORNER_LINES))); - SWIG_Python_SetConstant(d, "CORNER_NONE",SWIG_From_int(static_cast< int >(aruco::CORNER_NONE))); - SWIG_Python_SetConstant(d, "MarkerMap_NONE",SWIG_From_int(static_cast< int >(aruco::MarkerMap::NONE))); - SWIG_Python_SetConstant(d, "MarkerMap_PIX",SWIG_From_int(static_cast< int >(aruco::MarkerMap::PIX))); - SWIG_Python_SetConstant(d, "MarkerMap_METERS",SWIG_From_int(static_cast< int >(aruco::MarkerMap::METERS))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_2L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_2L_6))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_3L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_3L_6))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_4L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_4L_6))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_FRACTAL_5L_6",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::FRACTAL_5L_6))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_CUSTOM",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::CUSTOM))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_NONE",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::NONE))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_PIX",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::PIX))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_METERS",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::METERS))); - SWIG_Python_SetConstant(d, "FractalMarkerSet_NORM",SWIG_From_int(static_cast< int >(aruco::FractalMarkerSet::NORM))); - SWIG_Python_SetConstant(d, "ScopeTimer_NSEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::NSEC))); - SWIG_Python_SetConstant(d, "ScopeTimer_MSEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::MSEC))); - SWIG_Python_SetConstant(d, "ScopeTimer_SEC",SWIG_From_int(static_cast< int >(aruco::ScopeTimer::SEC))); - SWIG_Python_SetConstant(d, "ScopedTimerEvents_NSEC",SWIG_From_int(static_cast< int >(aruco::ScopedTimerEvents::NSEC))); - SWIG_Python_SetConstant(d, "ScopedTimerEvents_MSEC",SWIG_From_int(static_cast< int >(aruco::ScopedTimerEvents::MSEC))); - SWIG_Python_SetConstant(d, "ScopedTimerEvents_SEC",SWIG_From_int(static_cast< int >(aruco::ScopedTimerEvents::SEC))); - SWIG_Python_SetConstant(d, "Timer_NSEC",SWIG_From_int(static_cast< int >(aruco::Timer::NSEC))); - SWIG_Python_SetConstant(d, "Timer_MSEC",SWIG_From_int(static_cast< int >(aruco::Timer::MSEC))); - SWIG_Python_SetConstant(d, "Timer_SEC",SWIG_From_int(static_cast< int >(aruco::Timer::SEC))); -#if PY_VERSION_HEX >= 0x03000000 - return m; -#else - return; -#endif -} - diff --git a/example/example.py b/example/example.py index ff7148e..aa8cbd3 100644 --- a/example/example.py +++ b/example/example.py @@ -5,6 +5,7 @@ print(cv2.__version__) import numpy as np import aruco +print(aruco.__file__) import pkg_resources # part of setuptools if __name__ == '__main__': @@ -40,7 +41,16 @@ for i, point in enumerate(marker): print("\t{:d} {}".format(i, str(point))) marker.draw(frame, np.array([255, 255, 255]), 2) - print("3D points: {:}".format(marker.get3DPoints())) + # points3d = marker.get3DPoints() + # print("3D points: {:}".format(points3d)) + # for p in points3d: + # print("\t{}".format(p)) + print("center: {}".format(marker.getCenter())) + print("contour: {}".format(marker.contourPoints)) + points3d = marker.get3DPoints() + print("3D points: {:}".format(points3d)) + for p in points3d: + print("\t{}".format(p)) # calculate marker extrinsics for marker size of 3.5cm marker.calculateExtrinsics(0.035, camparam) diff --git a/okapi-typemaps.i b/okapi-typemaps.i index 02c8815..8ee67c0 100644 --- a/okapi-typemaps.i +++ b/okapi-typemaps.i @@ -236,6 +236,21 @@ import_array(); PyObject* array = PyArray_SimpleNewFromData(1, &dims, NPY_FLOAT, data); return array; } + + PyObject* point3fvec_to_array(std::vector* v) + { + npy_intp dims = 3; + npy_intp strides[1] = { 1 }; + int flags = NPY_WRITEABLE; + float *data = new float[3*v->size()]; + for(size_t i=0; isize(); i++){ + data[i*3] = v->at(i).x; + data[i*3+1] = v->at(i).y; + data[i*3+2] = v->at(i).z; + } + PyObject* array = PyArray_SimpleNewFromData(v->size(), &dims, NPY_FLOAT, data); + return array; + } } /////////////////////////////////////// @@ -600,7 +615,7 @@ import_array(); /////////////////////////////////////// %typemap(out, - fragment="OKAPI_Fragments") + fragment="OKAPI_Fragments") cv::Point2f { PyObject* array = point2f_to_array(&$1); @@ -625,3 +640,25 @@ cv::Point3f $result = array; } +// %typemap(out, +// fragment="OKAPI_Fragments") +// std::vector< cv::Point3f >::value_type * +// { +// PyObject* array = point3f_to_array($1); +// if (array == NULL) +// SWIG_fail; +// +// $result = array; +// } + + +// %typemap(out, +// fragment="OKAPI_Fragments") +// cv::Point3f * +// { +// PyObject* array = point3f_to_array($1); +// if (array == NULL) +// SWIG_fail; +// +// $result = array; +// } \ No newline at end of file diff --git a/setup.py b/setup.py index 3536eec..26bf3ee 100644 --- a/setup.py +++ b/setup.py @@ -29,7 +29,7 @@ sources=sourcefiles, language="c++", extra_compile_args=extra_cpp_args, - include_dirs=["/usr/local/include/opencv4/", "/usr/local/include/opencv2", "/usr/include/eigen3/", "src/"], + include_dirs=["/usr/local/include/opencv2", "/usr/include/eigen3/", "src/"], libraries=["opencv_core", "opencv_imgproc", "opencv_calib3d", "opencv_highgui", "opencv_ml"], library_dirs=["/usr/local/lib"]) @@ -43,8 +43,7 @@ license="Copyright 2011 Rafael Muñoz Salinas. All rights reserved.", url='https://github.com/fehlfarbe/python-aruco', keywords='aruco wrapper', - # install_requires=['numpy', 'opencv-contrib-python'], - install_requires=['numpy'], + install_requires=['numpy', 'opencv-contrib-python'], ext_modules=[aruco_module], py_modules=["aruco"], ) diff --git a/src/aruco/marker.cpp b/src/aruco/marker.cpp index 0d37ecc..26aecf5 100644 --- a/src/aruco/marker.cpp +++ b/src/aruco/marker.cpp @@ -365,7 +365,11 @@ namespace aruco // res[3]=cv::Point3f(-halfSize,- halfSize, 0); // return res; return {cv::Point3f(-halfSize, halfSize, 0),cv::Point3f(halfSize, halfSize, 0),cv::Point3f(halfSize,-halfSize, 0),cv::Point3f(-halfSize, -halfSize, 0)}; + } + + std::vector Marker::get3DPoints() const { + return get3DPoints(ssize); } void Marker::rotateXAxis( cv::Mat& rotation) diff --git a/src/aruco/marker.h b/src/aruco/marker.h index c9ecea4..c0ef852 100644 --- a/src/aruco/marker.h +++ b/src/aruco/marker.h @@ -176,11 +176,9 @@ or implied, of Rafael Muñoz Salinas. void fromStream(std::istream& str); // returns the 3d points of a marker wrt its center - static vector get3DPoints(float msize); + static std::vector get3DPoints(float msize); //returns the 3d points of this marker wrt its center - inline vector get3DPoints()const{ - return get3DPoints(ssize); - } + std::vector get3DPoints() const; //returns the SE3 (4x4) transform matrix diff --git a/swigbuild.sh b/swigbuild.sh index 08045e1..6d01746 100755 --- a/swigbuild.sh +++ b/swigbuild.sh @@ -4,11 +4,9 @@ if [ $# -gt 0 ] then if [ $1 == python3 ] then - SWIG_PYTHON="python -py3" PYTHON_INTERPRETER="python3" fi else - SWIG_PYTHON="python" PYTHON_INTERPRETER="python" fi From 3a306f067ad9730124bb4487bed22012b07fde0b Mon Sep 17 00:00:00 2001 From: byteofsoren Date: Sun, 16 Aug 2020 22:36:04 +0200 Subject: [PATCH 12/22] Changed so it installs on Archlinux Signed-off-by: byteofsoren --- README.md | 3 ++- setup.py | 9 ++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 6856018..8f90330 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,8 @@ Installation Python3 1. Install / compile [OpenCV](http://opencv.org/) >= 2.4.9 with Python3 support. [Install-OpenCV script helps to install the latest version.](https://github.com/jayrambhia/Install-OpenCV/) 3. Install swig3: `sudo apt-get install swig3.0` for Debian/Ubuntu like systems. On 14.04 and other older systems you will need to go to "Software Sources" and check backports in the Updates tab, and reload before installing. 4. Install NumPy `sudo pip3 install numpy` (maybe you already need it for OpenCV Python support) or install via system package manager. -5. run `./swigbuild.sh python3`: it compiles the shared library (_aruco.so) and generates Python3 wrappers (aruco.py) +5. Create a symlink `sudo ln -s /usr/local/include/opencv4/opencv2/ /usr/local/include/opencv2` +6. run `./swigbuild.sh python3`: it compiles the shared library (_aruco.so) and generates Python3 wrappers (aruco.py) 6. run `sudo python3 setup.py install` to install the library globally Test diff --git a/setup.py b/setup.py index a2c594e..abe2729 100644 --- a/setup.py +++ b/setup.py @@ -4,6 +4,7 @@ from setuptools import setup, Extension import shutil import sys +import numpy as np import glob # use python2/3 version of aruco @@ -29,7 +30,13 @@ sources=sourcefiles, language="c++", extra_compile_args=extra_cpp_args, - include_dirs=["/usr/local/include/opencv4/", "/usr/local/include/opencv2", "/usr/include/eigen3/", "src/"], + include_dirs=[ + np.get_include(), + "/usr/local/include/opencv4/", + "/usr/include/opencv4/opencv2/", + "/usr/local/include/opencv2", + "/usr/include/eigen3/", + "src/"], libraries=["opencv_core", "opencv_imgproc", "opencv_calib3d", "opencv_highgui", "opencv_ml"], library_dirs=["/usr/local/lib"]) From 5bcb3a224358396ed9cff5cfa1a3c3afa8d2879b Mon Sep 17 00:00:00 2001 From: fehlfarbe Date: Sun, 13 Dec 2020 21:16:49 +0100 Subject: [PATCH 13/22] Updated to aruco 3.1.12: - Added Eigen3 from aruco - Removed not implemented methods from aruco includes - Changed to CMake project --- .gitignore | 3 + 3rdparty/eigen3/Eigen/CMakeLists.txt | 19 + 3rdparty/eigen3/Eigen/Cholesky | 46 + 3rdparty/eigen3/Eigen/CholmodSupport | 48 + 3rdparty/eigen3/Eigen/Core | 537 + 3rdparty/eigen3/Eigen/Dense | 7 + 3rdparty/eigen3/Eigen/Eigen | 2 + 3rdparty/eigen3/Eigen/Eigenvalues | 61 + 3rdparty/eigen3/Eigen/Geometry | 62 + 3rdparty/eigen3/Eigen/Householder | 30 + 3rdparty/eigen3/Eigen/IterativeLinearSolvers | 48 + 3rdparty/eigen3/Eigen/Jacobi | 33 + 3rdparty/eigen3/Eigen/LU | 50 + 3rdparty/eigen3/Eigen/MetisSupport | 35 + 3rdparty/eigen3/Eigen/OrderingMethods | 73 + 3rdparty/eigen3/Eigen/PaStiXSupport | 48 + 3rdparty/eigen3/Eigen/PardisoSupport | 35 + 3rdparty/eigen3/Eigen/QR | 51 + 3rdparty/eigen3/Eigen/QtAlignedMalloc | 40 + 3rdparty/eigen3/Eigen/SPQRSupport | 34 + 3rdparty/eigen3/Eigen/SVD | 51 + 3rdparty/eigen3/Eigen/Sparse | 36 + 3rdparty/eigen3/Eigen/SparseCholesky | 45 + 3rdparty/eigen3/Eigen/SparseCore | 69 + 3rdparty/eigen3/Eigen/SparseLU | 46 + 3rdparty/eigen3/Eigen/SparseQR | 37 + 3rdparty/eigen3/Eigen/StdDeque | 27 + 3rdparty/eigen3/Eigen/StdList | 26 + 3rdparty/eigen3/Eigen/StdVector | 27 + 3rdparty/eigen3/Eigen/SuperLUSupport | 64 + 3rdparty/eigen3/Eigen/UmfPackSupport | 40 + 3rdparty/eigen3/Eigen/src/Cholesky/LDLT.h | 672 + 3rdparty/eigen3/Eigen/src/Cholesky/LLT.h | 542 + .../eigen3/Eigen/src/Cholesky/LLT_LAPACKE.h | 99 + .../Eigen/src/CholmodSupport/CholmodSupport.h | 639 + 3rdparty/eigen3/Eigen/src/Core/Array.h | 331 + 3rdparty/eigen3/Eigen/src/Core/ArrayBase.h | 226 + 3rdparty/eigen3/Eigen/src/Core/ArrayWrapper.h | 209 + 3rdparty/eigen3/Eigen/src/Core/Assign.h | 90 + .../eigen3/Eigen/src/Core/AssignEvaluator.h | 935 + 3rdparty/eigen3/Eigen/src/Core/Assign_MKL.h | 178 + 3rdparty/eigen3/Eigen/src/Core/BandMatrix.h | 353 + 3rdparty/eigen3/Eigen/src/Core/Block.h | 452 + 3rdparty/eigen3/Eigen/src/Core/BooleanRedux.h | 164 + .../eigen3/Eigen/src/Core/CommaInitializer.h | 160 + .../Eigen/src/Core/ConditionEstimator.h | 175 + .../eigen3/Eigen/src/Core/CoreEvaluators.h | 1688 ++ .../eigen3/Eigen/src/Core/CoreIterators.h | 127 + .../eigen3/Eigen/src/Core/CwiseBinaryOp.h | 184 + .../eigen3/Eigen/src/Core/CwiseNullaryOp.h | 866 + .../eigen3/Eigen/src/Core/CwiseTernaryOp.h | 197 + 3rdparty/eigen3/Eigen/src/Core/CwiseUnaryOp.h | 103 + .../eigen3/Eigen/src/Core/CwiseUnaryView.h | 128 + 3rdparty/eigen3/Eigen/src/Core/DenseBase.h | 611 + .../eigen3/Eigen/src/Core/DenseCoeffsBase.h | 681 + 3rdparty/eigen3/Eigen/src/Core/DenseStorage.h | 570 + 3rdparty/eigen3/Eigen/src/Core/Diagonal.h | 260 + .../eigen3/Eigen/src/Core/DiagonalMatrix.h | 343 + .../eigen3/Eigen/src/Core/DiagonalProduct.h | 28 + 3rdparty/eigen3/Eigen/src/Core/Dot.h | 318 + 3rdparty/eigen3/Eigen/src/Core/EigenBase.h | 159 + .../Eigen/src/Core/ForceAlignedAccess.h | 146 + 3rdparty/eigen3/Eigen/src/Core/Fuzzy.h | 155 + .../eigen3/Eigen/src/Core/GeneralProduct.h | 455 + .../eigen3/Eigen/src/Core/GenericPacketMath.h | 593 + .../eigen3/Eigen/src/Core/GlobalFunctions.h | 187 + 3rdparty/eigen3/Eigen/src/Core/IO.h | 225 + 3rdparty/eigen3/Eigen/src/Core/Inverse.h | 118 + 3rdparty/eigen3/Eigen/src/Core/Map.h | 171 + 3rdparty/eigen3/Eigen/src/Core/MapBase.h | 299 + .../eigen3/Eigen/src/Core/MathFunctions.h | 1407 ++ .../eigen3/Eigen/src/Core/MathFunctionsImpl.h | 101 + 3rdparty/eigen3/Eigen/src/Core/Matrix.h | 461 + 3rdparty/eigen3/Eigen/src/Core/MatrixBase.h | 521 + 3rdparty/eigen3/Eigen/src/Core/NestByValue.h | 110 + 3rdparty/eigen3/Eigen/src/Core/NoAlias.h | 108 + 3rdparty/eigen3/Eigen/src/Core/NumTraits.h | 248 + .../eigen3/Eigen/src/Core/PermutationMatrix.h | 633 + .../eigen3/Eigen/src/Core/PlainObjectBase.h | 1035 + 3rdparty/eigen3/Eigen/src/Core/Product.h | 186 + .../eigen3/Eigen/src/Core/ProductEvaluators.h | 1112 ++ 3rdparty/eigen3/Eigen/src/Core/Random.h | 182 + 3rdparty/eigen3/Eigen/src/Core/Redux.h | 505 + 3rdparty/eigen3/Eigen/src/Core/Ref.h | 283 + 3rdparty/eigen3/Eigen/src/Core/Replicate.h | 142 + .../eigen3/Eigen/src/Core/ReturnByValue.h | 117 + 3rdparty/eigen3/Eigen/src/Core/Reverse.h | 211 + 3rdparty/eigen3/Eigen/src/Core/Select.h | 162 + .../eigen3/Eigen/src/Core/SelfAdjointView.h | 352 + .../eigen3/Eigen/src/Core/SelfCwiseBinaryOp.h | 47 + 3rdparty/eigen3/Eigen/src/Core/Solve.h | 188 + .../eigen3/Eigen/src/Core/SolveTriangular.h | 232 + 3rdparty/eigen3/Eigen/src/Core/SolverBase.h | 130 + 3rdparty/eigen3/Eigen/src/Core/StableNorm.h | 221 + 3rdparty/eigen3/Eigen/src/Core/Stride.h | 111 + 3rdparty/eigen3/Eigen/src/Core/Swap.h | 67 + 3rdparty/eigen3/Eigen/src/Core/Transpose.h | 403 + .../eigen3/Eigen/src/Core/Transpositions.h | 407 + .../eigen3/Eigen/src/Core/TriangularMatrix.h | 983 + 3rdparty/eigen3/Eigen/src/Core/VectorBlock.h | 96 + 3rdparty/eigen3/Eigen/src/Core/VectorwiseOp.h | 695 + 3rdparty/eigen3/Eigen/src/Core/Visitor.h | 273 + .../eigen3/Eigen/src/Core/arch/AVX/Complex.h | 451 + .../Eigen/src/Core/arch/AVX/MathFunctions.h | 439 + .../Eigen/src/Core/arch/AVX/PacketMath.h | 636 + .../Eigen/src/Core/arch/AVX/TypeCasting.h | 51 + .../src/Core/arch/AVX512/MathFunctions.h | 391 + .../Eigen/src/Core/arch/AVX512/PacketMath.h | 1316 ++ .../Eigen/src/Core/arch/AltiVec/Complex.h | 430 + .../src/Core/arch/AltiVec/MathFunctions.h | 322 + .../Eigen/src/Core/arch/AltiVec/PacketMath.h | 1061 + .../eigen3/Eigen/src/Core/arch/CUDA/Complex.h | 103 + .../eigen3/Eigen/src/Core/arch/CUDA/Half.h | 651 + .../Eigen/src/Core/arch/CUDA/MathFunctions.h | 91 + .../Eigen/src/Core/arch/CUDA/PacketMath.h | 333 + .../Eigen/src/Core/arch/CUDA/PacketMathHalf.h | 1123 ++ .../Eigen/src/Core/arch/CUDA/TypeCasting.h | 212 + .../Eigen/src/Core/arch/Default/ConjHelper.h | 29 + .../Eigen/src/Core/arch/Default/Settings.h | 49 + .../eigen3/Eigen/src/Core/arch/NEON/Complex.h | 490 + .../Eigen/src/Core/arch/NEON/MathFunctions.h | 91 + .../Eigen/src/Core/arch/NEON/PacketMath.h | 760 + .../eigen3/Eigen/src/Core/arch/SSE/Complex.h | 471 + .../Eigen/src/Core/arch/SSE/MathFunctions.h | 562 + .../Eigen/src/Core/arch/SSE/PacketMath.h | 895 + .../Eigen/src/Core/arch/SSE/TypeCasting.h | 77 + .../Eigen/src/Core/arch/ZVector/Complex.h | 397 + .../src/Core/arch/ZVector/MathFunctions.h | 137 + .../Eigen/src/Core/arch/ZVector/PacketMath.h | 945 + .../src/Core/functors/AssignmentFunctors.h | 168 + .../Eigen/src/Core/functors/BinaryFunctors.h | 475 + .../Eigen/src/Core/functors/NullaryFunctors.h | 188 + .../Eigen/src/Core/functors/StlFunctors.h | 136 + .../Eigen/src/Core/functors/TernaryFunctors.h | 25 + .../Eigen/src/Core/functors/UnaryFunctors.h | 792 + .../Core/products/GeneralBlockPanelKernel.h | 2149 ++ .../src/Core/products/GeneralMatrixMatrix.h | 492 + .../products/GeneralMatrixMatrixTriangular.h | 311 + .../GeneralMatrixMatrixTriangular_BLAS.h | 145 + .../Core/products/GeneralMatrixMatrix_BLAS.h | 122 + .../src/Core/products/GeneralMatrixVector.h | 619 + .../Core/products/GeneralMatrixVector_BLAS.h | 136 + .../Eigen/src/Core/products/Parallelizer.h | 163 + .../Core/products/SelfadjointMatrixMatrix.h | 521 + .../products/SelfadjointMatrixMatrix_BLAS.h | 287 + .../Core/products/SelfadjointMatrixVector.h | 260 + .../products/SelfadjointMatrixVector_BLAS.h | 118 + .../src/Core/products/SelfadjointProduct.h | 133 + .../Core/products/SelfadjointRank2Update.h | 93 + .../Core/products/TriangularMatrixMatrix.h | 466 + .../products/TriangularMatrixMatrix_BLAS.h | 315 + .../Core/products/TriangularMatrixVector.h | 350 + .../products/TriangularMatrixVector_BLAS.h | 255 + .../Core/products/TriangularSolverMatrix.h | 335 + .../products/TriangularSolverMatrix_BLAS.h | 163 + .../Core/products/TriangularSolverVector.h | 145 + .../eigen3/Eigen/src/Core/util/BlasUtil.h | 398 + .../eigen3/Eigen/src/Core/util/Constants.h | 547 + .../src/Core/util/DisableStupidWarnings.h | 75 + .../Eigen/src/Core/util/ForwardDeclarations.h | 302 + .../eigen3/Eigen/src/Core/util/MKL_support.h | 130 + 3rdparty/eigen3/Eigen/src/Core/util/Macros.h | 1001 + 3rdparty/eigen3/Eigen/src/Core/util/Memory.h | 985 + 3rdparty/eigen3/Eigen/src/Core/util/Meta.h | 512 + 3rdparty/eigen3/Eigen/src/Core/util/NonMPL2.h | 3 + .../src/Core/util/ReenableStupidWarnings.h | 27 + .../eigen3/Eigen/src/Core/util/StaticAssert.h | 218 + .../eigen3/Eigen/src/Core/util/XprHelper.h | 821 + .../src/Eigenvalues/ComplexEigenSolver.h | 346 + .../Eigen/src/Eigenvalues/ComplexSchur.h | 459 + .../src/Eigenvalues/ComplexSchur_LAPACKE.h | 91 + .../Eigen/src/Eigenvalues/EigenSolver.h | 622 + .../src/Eigenvalues/GeneralizedEigenSolver.h | 418 + .../GeneralizedSelfAdjointEigenSolver.h | 226 + .../src/Eigenvalues/HessenbergDecomposition.h | 374 + .../src/Eigenvalues/MatrixBaseEigenvalues.h | 160 + .../eigen3/Eigen/src/Eigenvalues/RealQZ.h | 654 + .../eigen3/Eigen/src/Eigenvalues/RealSchur.h | 546 + .../Eigen/src/Eigenvalues/RealSchur_LAPACKE.h | 77 + .../src/Eigenvalues/SelfAdjointEigenSolver.h | 870 + .../SelfAdjointEigenSolver_LAPACKE.h | 87 + .../src/Eigenvalues/Tridiagonalization.h | 556 + .../eigen3/Eigen/src/Geometry/AlignedBox.h | 392 + .../eigen3/Eigen/src/Geometry/AngleAxis.h | 247 + .../eigen3/Eigen/src/Geometry/EulerAngles.h | 114 + .../eigen3/Eigen/src/Geometry/Homogeneous.h | 497 + .../eigen3/Eigen/src/Geometry/Hyperplane.h | 282 + .../eigen3/Eigen/src/Geometry/OrthoMethods.h | 234 + .../Eigen/src/Geometry/ParametrizedLine.h | 195 + .../eigen3/Eigen/src/Geometry/Quaternion.h | 814 + .../eigen3/Eigen/src/Geometry/Rotation2D.h | 199 + .../eigen3/Eigen/src/Geometry/RotationBase.h | 206 + 3rdparty/eigen3/Eigen/src/Geometry/Scaling.h | 170 + .../eigen3/Eigen/src/Geometry/Transform.h | 1542 ++ .../eigen3/Eigen/src/Geometry/Translation.h | 208 + 3rdparty/eigen3/Eigen/src/Geometry/Umeyama.h | 166 + .../Eigen/src/Geometry/arch/Geometry_SSE.h | 161 + .../Eigen/src/Householder/BlockHouseholder.h | 103 + .../Eigen/src/Householder/Householder.h | 172 + .../src/Householder/HouseholderSequence.h | 470 + .../BasicPreconditioners.h | 226 + .../src/IterativeLinearSolvers/BiCGSTAB.h | 228 + .../ConjugateGradient.h | 245 + .../IncompleteCholesky.h | 400 + .../IterativeLinearSolvers/IncompleteLUT.h | 462 + .../IterativeSolverBase.h | 394 + .../LeastSquareConjugateGradient.h | 216 + .../IterativeLinearSolvers/SolveWithGuess.h | 115 + 3rdparty/eigen3/Eigen/src/Jacobi/Jacobi.h | 463 + 3rdparty/eigen3/Eigen/src/LU/Determinant.h | 101 + 3rdparty/eigen3/Eigen/src/LU/FullPivLU.h | 891 + 3rdparty/eigen3/Eigen/src/LU/InverseImpl.h | 415 + 3rdparty/eigen3/Eigen/src/LU/PartialPivLU.h | 611 + .../Eigen/src/LU/PartialPivLU_LAPACKE.h | 83 + .../eigen3/Eigen/src/LU/arch/Inverse_SSE.h | 338 + .../Eigen/src/MetisSupport/MetisSupport.h | 137 + .../eigen3/Eigen/src/OrderingMethods/Amd.h | 445 + .../Eigen/src/OrderingMethods/Eigen_Colamd.h | 1843 ++ .../Eigen/src/OrderingMethods/Ordering.h | 157 + .../Eigen/src/PaStiXSupport/PaStiXSupport.h | 678 + .../Eigen/src/PardisoSupport/PardisoSupport.h | 543 + .../eigen3/Eigen/src/QR/ColPivHouseholderQR.h | 653 + .../src/QR/ColPivHouseholderQR_LAPACKE.h | 97 + .../src/QR/CompleteOrthogonalDecomposition.h | 562 + .../Eigen/src/QR/FullPivHouseholderQR.h | 676 + 3rdparty/eigen3/Eigen/src/QR/HouseholderQR.h | 409 + .../Eigen/src/QR/HouseholderQR_LAPACKE.h | 68 + .../src/SPQRSupport/SuiteSparseQRSupport.h | 313 + 3rdparty/eigen3/Eigen/src/SVD/BDCSVD.h | 1246 ++ 3rdparty/eigen3/Eigen/src/SVD/JacobiSVD.h | 804 + .../eigen3/Eigen/src/SVD/JacobiSVD_LAPACKE.h | 91 + 3rdparty/eigen3/Eigen/src/SVD/SVDBase.h | 313 + .../Eigen/src/SVD/UpperBidiagonalization.h | 414 + .../src/SparseCholesky/SimplicialCholesky.h | 689 + .../SparseCholesky/SimplicialCholesky_impl.h | 199 + .../eigen3/Eigen/src/SparseCore/AmbiVector.h | 377 + .../Eigen/src/SparseCore/CompressedStorage.h | 258 + .../ConservativeSparseSparseProduct.h | 352 + .../Eigen/src/SparseCore/MappedSparseMatrix.h | 67 + .../Eigen/src/SparseCore/SparseAssign.h | 216 + .../eigen3/Eigen/src/SparseCore/SparseBlock.h | 603 + .../Eigen/src/SparseCore/SparseColEtree.h | 206 + .../src/SparseCore/SparseCompressedBase.h | 341 + .../src/SparseCore/SparseCwiseBinaryOp.h | 726 + .../Eigen/src/SparseCore/SparseCwiseUnaryOp.h | 148 + .../Eigen/src/SparseCore/SparseDenseProduct.h | 320 + .../src/SparseCore/SparseDiagonalProduct.h | 138 + .../eigen3/Eigen/src/SparseCore/SparseDot.h | 98 + .../eigen3/Eigen/src/SparseCore/SparseFuzzy.h | 29 + .../eigen3/Eigen/src/SparseCore/SparseMap.h | 305 + .../Eigen/src/SparseCore/SparseMatrix.h | 1403 ++ .../Eigen/src/SparseCore/SparseMatrixBase.h | 405 + .../Eigen/src/SparseCore/SparsePermutation.h | 178 + .../Eigen/src/SparseCore/SparseProduct.h | 169 + .../eigen3/Eigen/src/SparseCore/SparseRedux.h | 49 + .../eigen3/Eigen/src/SparseCore/SparseRef.h | 397 + .../src/SparseCore/SparseSelfAdjointView.h | 656 + .../Eigen/src/SparseCore/SparseSolverBase.h | 124 + .../SparseSparseProductWithPruning.h | 198 + .../Eigen/src/SparseCore/SparseTranspose.h | 92 + .../src/SparseCore/SparseTriangularView.h | 189 + .../eigen3/Eigen/src/SparseCore/SparseUtil.h | 178 + .../Eigen/src/SparseCore/SparseVector.h | 478 + .../eigen3/Eigen/src/SparseCore/SparseView.h | 253 + .../Eigen/src/SparseCore/TriangularSolver.h | 315 + 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU.h | 775 + .../eigen3/Eigen/src/SparseLU/SparseLUImpl.h | 66 + .../Eigen/src/SparseLU/SparseLU_Memory.h | 226 + .../Eigen/src/SparseLU/SparseLU_Structs.h | 110 + .../src/SparseLU/SparseLU_SupernodalMatrix.h | 301 + .../Eigen/src/SparseLU/SparseLU_Utils.h | 80 + .../Eigen/src/SparseLU/SparseLU_column_bmod.h | 181 + .../Eigen/src/SparseLU/SparseLU_column_dfs.h | 179 + .../src/SparseLU/SparseLU_copy_to_ucol.h | 107 + .../Eigen/src/SparseLU/SparseLU_gemm_kernel.h | 280 + .../src/SparseLU/SparseLU_heap_relax_snode.h | 126 + .../Eigen/src/SparseLU/SparseLU_kernel_bmod.h | 130 + .../Eigen/src/SparseLU/SparseLU_panel_bmod.h | 223 + .../Eigen/src/SparseLU/SparseLU_panel_dfs.h | 258 + .../Eigen/src/SparseLU/SparseLU_pivotL.h | 137 + .../Eigen/src/SparseLU/SparseLU_pruneL.h | 136 + .../Eigen/src/SparseLU/SparseLU_relax_snode.h | 83 + 3rdparty/eigen3/Eigen/src/SparseQR/SparseQR.h | 745 + .../eigen3/Eigen/src/StlSupport/StdDeque.h | 126 + .../eigen3/Eigen/src/StlSupport/StdList.h | 106 + .../eigen3/Eigen/src/StlSupport/StdVector.h | 131 + .../eigen3/Eigen/src/StlSupport/details.h | 84 + .../Eigen/src/SuperLUSupport/SuperLUSupport.h | 1027 + .../Eigen/src/UmfPackSupport/UmfPackSupport.h | 506 + 3rdparty/eigen3/Eigen/src/misc/Image.h | 82 + 3rdparty/eigen3/Eigen/src/misc/Kernel.h | 79 + 3rdparty/eigen3/Eigen/src/misc/RealSvd2x2.h | 55 + 3rdparty/eigen3/Eigen/src/misc/blas.h | 440 + 3rdparty/eigen3/Eigen/src/misc/lapack.h | 152 + 3rdparty/eigen3/Eigen/src/misc/lapacke.h | 16291 +++++++++++++++ .../eigen3/Eigen/src/misc/lapacke_mangling.h | 17 + .../Eigen/src/plugins/ArrayCwiseBinaryOps.h | 332 + .../Eigen/src/plugins/ArrayCwiseUnaryOps.h | 552 + .../eigen3/Eigen/src/plugins/BlockMethods.h | 1058 + .../Eigen/src/plugins/CommonCwiseBinaryOps.h | 115 + .../Eigen/src/plugins/CommonCwiseUnaryOps.h | 163 + .../Eigen/src/plugins/MatrixCwiseBinaryOps.h | 152 + .../Eigen/src/plugins/MatrixCwiseUnaryOps.h | 85 + CMakeLists.txt | 13 + MANIFEST.in | 5 - README.md | 53 +- aruco.i | 249 - aruco_wrap.h | 18 - build_wheel.sh | 24 - cmake/python.cmake | 112 + example/example.py | 17 +- example/fractal.py | 5 +- {src/aruco => include}/aruco.h | 0 {src/aruco => include}/aruco_cvversioning.h | 2 + {src/aruco => include}/aruco_export.h | 0 {src/aruco => include}/cameraparameters.h | 0 {src/aruco => include}/cvdrawingutils.h | 0 include/dcf/dcf_utils.h | 29 + include/dcf/dcfmarkermaptracker.h | 36 + include/dcf/dcfmarkertracker.h | 38 + include/dcf/trackerimpl.h | 93 + {src/aruco => include}/debug.h | 0 {src/aruco => include}/dictionary.h | 21 +- .../dictionary_based.h | 70 +- {src/aruco => include}/fractaldetector.h | 7 +- .../fractallabelers/fractallabeler.h | 10 +- .../fractallabelers/fractalmarker.h | 18 +- .../fractallabelers/fractalmarkerset.h | 7 +- .../fractallabelers/fractalposetracker.h | 34 +- {src/aruco => include}/ippe.h | 44 +- {src/aruco => include}/levmarq.h | 0 {src/aruco => include}/marker.h | 6 +- {src/aruco => include}/markerdetector.h | 39 +- include/markerdetector_impl.h | 465 + {src/aruco => include}/markerlabeler.h | 0 {src/aruco => include}/markermap.h | 0 {src/aruco => include}/picoflann.h | 0 {src/aruco => include}/posetracker.h | 2 +- {src/aruco => include}/timers.h | 0 python/CMakeLists.txt | 53 + python/__init__.py.in | 1 + python/aruco.i | 147 + numpy_old.i => python/numpy_old.i | 0 okapi-typemaps.i => python/okapi-typemaps.i | 0 python/setup.py.in | 33 + setup.cfg | 5 - setup.py | 50 - src/aruco/CMakeLists.txt | 54 - src/aruco/cameraparameters.cpp | 609 - src/aruco/cvdrawingutils.cpp | 174 - src/aruco/debug.cpp | 67 - src/aruco/dictionary.cpp | 538 - src/aruco/dictionary_based.cpp | 4583 ----- src/aruco/dictionary_based.h | 2743 --- src/aruco/fractaldetector.cpp | 145 - src/aruco/fractallabelers/fractallabeler.cpp | 152 - src/aruco/fractallabelers/fractalmarker.cpp | 72 - .../fractallabelers/fractalmarkerset.cpp | 828 - .../fractallabelers/fractalposetracker.cpp | 947 - src/aruco/ippe.cpp | 1169 -- src/aruco/marker.cpp | 499 - src/aruco/markerdetector.cpp | 393 - src/aruco/markerdetector_impl.cpp | 16552 ---------------- src/aruco/markerdetector_impl.h | 3787 ---- src/aruco/markermap.cpp | 466 - src/aruco/posetracker.cpp | 554 - swigbuild.sh | 28 - 367 files changed, 117567 insertions(+), 34836 deletions(-) create mode 100644 3rdparty/eigen3/Eigen/CMakeLists.txt create mode 100644 3rdparty/eigen3/Eigen/Cholesky create mode 100644 3rdparty/eigen3/Eigen/CholmodSupport create mode 100644 3rdparty/eigen3/Eigen/Core create mode 100644 3rdparty/eigen3/Eigen/Dense create mode 100644 3rdparty/eigen3/Eigen/Eigen create mode 100644 3rdparty/eigen3/Eigen/Eigenvalues create mode 100644 3rdparty/eigen3/Eigen/Geometry create mode 100644 3rdparty/eigen3/Eigen/Householder create mode 100644 3rdparty/eigen3/Eigen/IterativeLinearSolvers create mode 100644 3rdparty/eigen3/Eigen/Jacobi create mode 100644 3rdparty/eigen3/Eigen/LU create mode 100644 3rdparty/eigen3/Eigen/MetisSupport create mode 100644 3rdparty/eigen3/Eigen/OrderingMethods create mode 100644 3rdparty/eigen3/Eigen/PaStiXSupport create mode 100755 3rdparty/eigen3/Eigen/PardisoSupport create mode 100644 3rdparty/eigen3/Eigen/QR create mode 100644 3rdparty/eigen3/Eigen/QtAlignedMalloc create mode 100644 3rdparty/eigen3/Eigen/SPQRSupport create mode 100644 3rdparty/eigen3/Eigen/SVD create mode 100644 3rdparty/eigen3/Eigen/Sparse create mode 100644 3rdparty/eigen3/Eigen/SparseCholesky create mode 100644 3rdparty/eigen3/Eigen/SparseCore create mode 100644 3rdparty/eigen3/Eigen/SparseLU create mode 100644 3rdparty/eigen3/Eigen/SparseQR create mode 100644 3rdparty/eigen3/Eigen/StdDeque create mode 100644 3rdparty/eigen3/Eigen/StdList create mode 100644 3rdparty/eigen3/Eigen/StdVector create mode 100644 3rdparty/eigen3/Eigen/SuperLUSupport create mode 100644 3rdparty/eigen3/Eigen/UmfPackSupport create mode 100644 3rdparty/eigen3/Eigen/src/Cholesky/LDLT.h create mode 100644 3rdparty/eigen3/Eigen/src/Cholesky/LLT.h create mode 100644 3rdparty/eigen3/Eigen/src/Cholesky/LLT_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/CholmodSupport/CholmodSupport.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Array.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/ArrayBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/ArrayWrapper.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Assign.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/AssignEvaluator.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/Assign_MKL.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/BandMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Block.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/BooleanRedux.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CommaInitializer.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/ConditionEstimator.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CoreEvaluators.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CoreIterators.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CwiseBinaryOp.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CwiseNullaryOp.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CwiseTernaryOp.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CwiseUnaryOp.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/CwiseUnaryView.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/DenseBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/DenseCoeffsBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/DenseStorage.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Diagonal.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/DiagonalMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/DiagonalProduct.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Dot.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/EigenBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/ForceAlignedAccess.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Fuzzy.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/GeneralProduct.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/GenericPacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/GlobalFunctions.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/IO.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Inverse.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Map.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/MapBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/MathFunctions.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/MathFunctionsImpl.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Matrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/MatrixBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/NestByValue.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/NoAlias.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/NumTraits.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/PermutationMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/PlainObjectBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Product.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/ProductEvaluators.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Random.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Redux.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Ref.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Replicate.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/ReturnByValue.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Reverse.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Select.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/SelfAdjointView.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/SelfCwiseBinaryOp.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Solve.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/SolveTriangular.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/SolverBase.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/StableNorm.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Stride.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Swap.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Transpose.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Transpositions.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/TriangularMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/VectorBlock.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/VectorwiseOp.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/Visitor.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AVX/Complex.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AVX/MathFunctions.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AVX/PacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AVX/TypeCasting.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AVX512/MathFunctions.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AVX512/PacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AltiVec/Complex.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/AltiVec/MathFunctions.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/arch/AltiVec/PacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/CUDA/Complex.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/CUDA/Half.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/CUDA/MathFunctions.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/CUDA/PacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/CUDA/PacketMathHalf.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/CUDA/TypeCasting.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/Default/ConjHelper.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/Default/Settings.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/NEON/Complex.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/NEON/MathFunctions.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/NEON/PacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/SSE/Complex.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/SSE/MathFunctions.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/arch/SSE/PacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/SSE/TypeCasting.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/ZVector/Complex.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/arch/ZVector/MathFunctions.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/arch/ZVector/PacketMath.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/functors/AssignmentFunctors.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/functors/BinaryFunctors.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/functors/NullaryFunctors.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/functors/StlFunctors.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/functors/TernaryFunctors.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/functors/UnaryFunctors.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/GeneralBlockPanelKernel.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/GeneralMatrixMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/GeneralMatrixVector.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/Parallelizer.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/SelfadjointMatrixMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/SelfadjointMatrixVector.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/SelfadjointProduct.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/SelfadjointRank2Update.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/TriangularMatrixMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/TriangularMatrixVector.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/TriangularSolverMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/products/TriangularSolverVector.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/util/BlasUtil.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/Constants.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/util/DisableStupidWarnings.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/ForwardDeclarations.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/util/MKL_support.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/Macros.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/Memory.h create mode 100755 3rdparty/eigen3/Eigen/src/Core/util/Meta.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/NonMPL2.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/ReenableStupidWarnings.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/StaticAssert.h create mode 100644 3rdparty/eigen3/Eigen/src/Core/util/XprHelper.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/ComplexEigenSolver.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/ComplexSchur.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/EigenSolver.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/HessenbergDecomposition.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/RealQZ.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/RealSchur.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/Eigenvalues/Tridiagonalization.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/AlignedBox.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/AngleAxis.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/EulerAngles.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/Homogeneous.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/Hyperplane.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/OrthoMethods.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/ParametrizedLine.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/Quaternion.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/Rotation2D.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/RotationBase.h create mode 100755 3rdparty/eigen3/Eigen/src/Geometry/Scaling.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/Transform.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/Translation.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/Umeyama.h create mode 100644 3rdparty/eigen3/Eigen/src/Geometry/arch/Geometry_SSE.h create mode 100644 3rdparty/eigen3/Eigen/src/Householder/BlockHouseholder.h create mode 100644 3rdparty/eigen3/Eigen/src/Householder/Householder.h create mode 100644 3rdparty/eigen3/Eigen/src/Householder/HouseholderSequence.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h create mode 100644 3rdparty/eigen3/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h create mode 100644 3rdparty/eigen3/Eigen/src/Jacobi/Jacobi.h create mode 100644 3rdparty/eigen3/Eigen/src/LU/Determinant.h create mode 100644 3rdparty/eigen3/Eigen/src/LU/FullPivLU.h create mode 100644 3rdparty/eigen3/Eigen/src/LU/InverseImpl.h create mode 100644 3rdparty/eigen3/Eigen/src/LU/PartialPivLU.h create mode 100644 3rdparty/eigen3/Eigen/src/LU/PartialPivLU_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/LU/arch/Inverse_SSE.h create mode 100644 3rdparty/eigen3/Eigen/src/MetisSupport/MetisSupport.h create mode 100644 3rdparty/eigen3/Eigen/src/OrderingMethods/Amd.h create mode 100644 3rdparty/eigen3/Eigen/src/OrderingMethods/Eigen_Colamd.h create mode 100644 3rdparty/eigen3/Eigen/src/OrderingMethods/Ordering.h create mode 100644 3rdparty/eigen3/Eigen/src/PaStiXSupport/PaStiXSupport.h create mode 100644 3rdparty/eigen3/Eigen/src/PardisoSupport/PardisoSupport.h create mode 100644 3rdparty/eigen3/Eigen/src/QR/ColPivHouseholderQR.h create mode 100644 3rdparty/eigen3/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/QR/CompleteOrthogonalDecomposition.h create mode 100644 3rdparty/eigen3/Eigen/src/QR/FullPivHouseholderQR.h create mode 100644 3rdparty/eigen3/Eigen/src/QR/HouseholderQR.h create mode 100644 3rdparty/eigen3/Eigen/src/QR/HouseholderQR_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h create mode 100644 3rdparty/eigen3/Eigen/src/SVD/BDCSVD.h create mode 100644 3rdparty/eigen3/Eigen/src/SVD/JacobiSVD.h create mode 100644 3rdparty/eigen3/Eigen/src/SVD/JacobiSVD_LAPACKE.h create mode 100644 3rdparty/eigen3/Eigen/src/SVD/SVDBase.h create mode 100644 3rdparty/eigen3/Eigen/src/SVD/UpperBidiagonalization.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCholesky/SimplicialCholesky.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/AmbiVector.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/CompressedStorage.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/MappedSparseMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseAssign.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseBlock.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseColEtree.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseCompressedBase.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseCwiseBinaryOp.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseCwiseUnaryOp.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseDenseProduct.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseDiagonalProduct.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseDot.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseFuzzy.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseMap.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseMatrixBase.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparsePermutation.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseProduct.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseRedux.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseRef.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseSelfAdjointView.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseSolverBase.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseSparseProductWithPruning.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseTranspose.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseTriangularView.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseUtil.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseVector.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/SparseView.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseCore/TriangularSolver.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLUImpl.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_Memory.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_Structs.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_Utils.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_column_bmod.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_column_dfs.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_gemm_kernel.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_kernel_bmod.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_panel_bmod.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_panel_dfs.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_pivotL.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_pruneL.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseLU/SparseLU_relax_snode.h create mode 100644 3rdparty/eigen3/Eigen/src/SparseQR/SparseQR.h create mode 100644 3rdparty/eigen3/Eigen/src/StlSupport/StdDeque.h create mode 100644 3rdparty/eigen3/Eigen/src/StlSupport/StdList.h create mode 100644 3rdparty/eigen3/Eigen/src/StlSupport/StdVector.h create mode 100644 3rdparty/eigen3/Eigen/src/StlSupport/details.h create mode 100644 3rdparty/eigen3/Eigen/src/SuperLUSupport/SuperLUSupport.h create mode 100644 3rdparty/eigen3/Eigen/src/UmfPackSupport/UmfPackSupport.h create mode 100644 3rdparty/eigen3/Eigen/src/misc/Image.h create mode 100644 3rdparty/eigen3/Eigen/src/misc/Kernel.h create mode 100644 3rdparty/eigen3/Eigen/src/misc/RealSvd2x2.h create mode 100644 3rdparty/eigen3/Eigen/src/misc/blas.h create mode 100644 3rdparty/eigen3/Eigen/src/misc/lapack.h create mode 100755 3rdparty/eigen3/Eigen/src/misc/lapacke.h create mode 100644 3rdparty/eigen3/Eigen/src/misc/lapacke_mangling.h create mode 100644 3rdparty/eigen3/Eigen/src/plugins/ArrayCwiseBinaryOps.h create mode 100644 3rdparty/eigen3/Eigen/src/plugins/ArrayCwiseUnaryOps.h create mode 100644 3rdparty/eigen3/Eigen/src/plugins/BlockMethods.h create mode 100644 3rdparty/eigen3/Eigen/src/plugins/CommonCwiseBinaryOps.h create mode 100644 3rdparty/eigen3/Eigen/src/plugins/CommonCwiseUnaryOps.h create mode 100644 3rdparty/eigen3/Eigen/src/plugins/MatrixCwiseBinaryOps.h create mode 100644 3rdparty/eigen3/Eigen/src/plugins/MatrixCwiseUnaryOps.h create mode 100644 CMakeLists.txt delete mode 100644 MANIFEST.in delete mode 100644 aruco.i delete mode 100644 aruco_wrap.h delete mode 100755 build_wheel.sh create mode 100644 cmake/python.cmake rename {src/aruco => include}/aruco.h (100%) rename {src/aruco => include}/aruco_cvversioning.h (86%) rename {src/aruco => include}/aruco_export.h (100%) rename {src/aruco => include}/cameraparameters.h (100%) rename {src/aruco => include}/cvdrawingutils.h (100%) create mode 100644 include/dcf/dcf_utils.h create mode 100644 include/dcf/dcfmarkermaptracker.h create mode 100644 include/dcf/dcfmarkertracker.h create mode 100644 include/dcf/trackerimpl.h rename {src/aruco => include}/debug.h (100%) rename {src/aruco => include}/dictionary.h (90%) rename src/aruco/markerlabeler.cpp => include/dictionary_based.h (51%) rename {src/aruco => include}/fractaldetector.h (93%) rename {src/aruco => include}/fractallabelers/fractallabeler.h (83%) rename {src/aruco => include}/fractallabelers/fractalmarker.h (74%) rename {src/aruco => include}/fractallabelers/fractalmarkerset.h (97%) rename {src/aruco => include}/fractallabelers/fractalposetracker.h (82%) rename {src/aruco => include}/ippe.h (86%) rename {src/aruco => include}/levmarq.h (100%) rename {src/aruco => include}/marker.h (97%) rename {src/aruco => include}/markerdetector.h (89%) create mode 100644 include/markerdetector_impl.h rename {src/aruco => include}/markerlabeler.h (100%) rename {src/aruco => include}/markermap.h (100%) rename {src/aruco => include}/picoflann.h (100%) rename {src/aruco => include}/posetracker.h (99%) rename {src/aruco => include}/timers.h (100%) create mode 100644 python/CMakeLists.txt create mode 100644 python/__init__.py.in create mode 100644 python/aruco.i rename numpy_old.i => python/numpy_old.i (100%) rename okapi-typemaps.i => python/okapi-typemaps.i (100%) create mode 100644 python/setup.py.in delete mode 100644 setup.cfg delete mode 100644 setup.py delete mode 100644 src/aruco/CMakeLists.txt delete mode 100644 src/aruco/cameraparameters.cpp delete mode 100644 src/aruco/cvdrawingutils.cpp delete mode 100644 src/aruco/debug.cpp delete mode 100644 src/aruco/dictionary.cpp delete mode 100644 src/aruco/dictionary_based.cpp delete mode 100644 src/aruco/dictionary_based.h delete mode 100644 src/aruco/fractaldetector.cpp delete mode 100644 src/aruco/fractallabelers/fractallabeler.cpp delete mode 100644 src/aruco/fractallabelers/fractalmarker.cpp delete mode 100644 src/aruco/fractallabelers/fractalmarkerset.cpp delete mode 100644 src/aruco/fractallabelers/fractalposetracker.cpp delete mode 100644 src/aruco/ippe.cpp delete mode 100644 src/aruco/marker.cpp delete mode 100644 src/aruco/markerdetector.cpp delete mode 100644 src/aruco/markerdetector_impl.cpp delete mode 100644 src/aruco/markerdetector_impl.h delete mode 100644 src/aruco/markermap.cpp delete mode 100644 src/aruco/posetracker.cpp delete mode 100755 swigbuild.sh diff --git a/.gitignore b/.gitignore index 07b4242..7a2d351 100644 --- a/.gitignore +++ b/.gitignore @@ -64,3 +64,6 @@ target/ #Ipython Notebook .ipynb_checkpoints +/cmake-build-debug/ +/venv/ +/src/ diff --git a/3rdparty/eigen3/Eigen/CMakeLists.txt b/3rdparty/eigen3/Eigen/CMakeLists.txt new file mode 100644 index 0000000..9eb502b --- /dev/null +++ b/3rdparty/eigen3/Eigen/CMakeLists.txt @@ -0,0 +1,19 @@ +include(RegexUtils) +test_escape_string_as_regex() + +file(GLOB Eigen_directory_files "*") + +escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") + +foreach(f ${Eigen_directory_files}) + if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src") + list(APPEND Eigen_directory_files_to_install ${f}) + endif() +endforeach(f ${Eigen_directory_files}) + +install(FILES + ${Eigen_directory_files_to_install} + DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel + ) + +install(DIRECTORY src DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel FILES_MATCHING PATTERN "*.h") diff --git a/3rdparty/eigen3/Eigen/Cholesky b/3rdparty/eigen3/Eigen/Cholesky new file mode 100644 index 0000000..1332b54 --- /dev/null +++ b/3rdparty/eigen3/Eigen/Cholesky @@ -0,0 +1,46 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CHOLESKY_MODULE_H +#define EIGEN_CHOLESKY_MODULE_H + +#include "Core" +#include "Jacobi" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** \defgroup Cholesky_Module Cholesky module + * + * + * + * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices. + * Those decompositions are also accessible via the following methods: + * - MatrixBase::llt() + * - MatrixBase::ldlt() + * - SelfAdjointView::llt() + * - SelfAdjointView::ldlt() + * + * \code + * #include + * \endcode + */ + +#include "src/Cholesky/LLT.h" +#include "src/Cholesky/LDLT.h" +#ifdef EIGEN_USE_LAPACKE +#ifdef EIGEN_USE_MKL +#include "mkl_lapacke.h" +#else +#include "src/misc/lapacke.h" +#endif +#include "src/Cholesky/LLT_LAPACKE.h" +#endif + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_CHOLESKY_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ diff --git a/3rdparty/eigen3/Eigen/CholmodSupport b/3rdparty/eigen3/Eigen/CholmodSupport new file mode 100644 index 0000000..bed8924 --- /dev/null +++ b/3rdparty/eigen3/Eigen/CholmodSupport @@ -0,0 +1,48 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H +#define EIGEN_CHOLMODSUPPORT_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +extern "C" { + #include +} + +/** \ingroup Support_modules + * \defgroup CholmodSupport_Module CholmodSupport module + * + * This module provides an interface to the Cholmod library which is part of the suitesparse package. + * It provides the two following main factorization classes: + * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization. + * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial). + * + * For the sake of completeness, this module also propose the two following classes: + * - class CholmodSimplicialLLT + * - class CholmodSimplicialLDLT + * Note that these classes does not bring any particular advantage compared to the built-in + * SimplicialLLT and SimplicialLDLT factorization classes. + * + * \code + * #include + * \endcode + * + * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies. + * The dependencies depend on how cholmod has been compiled. + * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task. + * + */ + +#include "src/CholmodSupport/CholmodSupport.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_CHOLMODSUPPORT_MODULE_H + diff --git a/3rdparty/eigen3/Eigen/Core b/3rdparty/eigen3/Eigen/Core new file mode 100644 index 0000000..4d4901e --- /dev/null +++ b/3rdparty/eigen3/Eigen/Core @@ -0,0 +1,537 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2007-2011 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CORE_H +#define EIGEN_CORE_H + +// first thing Eigen does: stop the compiler from committing suicide +#include "src/Core/util/DisableStupidWarnings.h" + +#if defined(__CUDACC__) && !defined(EIGEN_NO_CUDA) + #define EIGEN_CUDACC __CUDACC__ +#endif + +#if defined(__CUDA_ARCH__) && !defined(EIGEN_NO_CUDA) + #define EIGEN_CUDA_ARCH __CUDA_ARCH__ +#endif + +#if defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 9) +#define EIGEN_CUDACC_VER ((__CUDACC_VER_MAJOR__ * 10000) + (__CUDACC_VER_MINOR__ * 100)) +#elif defined(__CUDACC_VER__) +#define EIGEN_CUDACC_VER __CUDACC_VER__ +#else +#define EIGEN_CUDACC_VER 0 +#endif + +// Handle NVCC/CUDA/SYCL +#if defined(__CUDACC__) || defined(__SYCL_DEVICE_ONLY__) + // Do not try asserts on CUDA and SYCL! + #ifndef EIGEN_NO_DEBUG + #define EIGEN_NO_DEBUG + #endif + + #ifdef EIGEN_INTERNAL_DEBUGGING + #undef EIGEN_INTERNAL_DEBUGGING + #endif + + #ifdef EIGEN_EXCEPTIONS + #undef EIGEN_EXCEPTIONS + #endif + + // All functions callable from CUDA code must be qualified with __device__ + #ifdef __CUDACC__ + // Do not try to vectorize on CUDA and SYCL! + #ifndef EIGEN_DONT_VECTORIZE + #define EIGEN_DONT_VECTORIZE + #endif + + #define EIGEN_DEVICE_FUNC __host__ __device__ + // We need math_functions.hpp to ensure that that EIGEN_USING_STD_MATH macro + // works properly on the device side + #include + #else + #define EIGEN_DEVICE_FUNC + #endif + +#else + #define EIGEN_DEVICE_FUNC + +#endif + +// When compiling CUDA device code with NVCC, pull in math functions from the +// global namespace. In host mode, and when device doee with clang, use the +// std versions. +#if defined(__CUDA_ARCH__) && defined(__NVCC__) + #define EIGEN_USING_STD_MATH(FUNC) using ::FUNC; +#else + #define EIGEN_USING_STD_MATH(FUNC) using std::FUNC; +#endif + +#if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(__CUDA_ARCH__) && !defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_USE_SYCL) + #define EIGEN_EXCEPTIONS +#endif + +#ifdef EIGEN_EXCEPTIONS + #include +#endif + +// then include this file where all our macros are defined. It's really important to do it first because +// it's where we do all the alignment settings (platform detection and honoring the user's will if he +// defined e.g. EIGEN_DONT_ALIGN) so it needs to be done before we do anything with vectorization. +#include "src/Core/util/Macros.h" + +// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3) +// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details. +#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6) + #pragma GCC optimize ("-fno-ipa-cp-clone") +#endif + +#include + +// this include file manages BLAS and MKL related macros +// and inclusion of their respective header files +#include "src/Core/util/MKL_support.h" + +// if alignment is disabled, then disable vectorization. Note: EIGEN_MAX_ALIGN_BYTES is the proper check, it takes into +// account both the user's will (EIGEN_MAX_ALIGN_BYTES,EIGEN_DONT_ALIGN) and our own platform checks +#if EIGEN_MAX_ALIGN_BYTES==0 + #ifndef EIGEN_DONT_VECTORIZE + #define EIGEN_DONT_VECTORIZE + #endif +#endif + +#if EIGEN_COMP_MSVC + #include // for _aligned_malloc -- need it regardless of whether vectorization is enabled + #if (EIGEN_COMP_MSVC >= 1500) // 2008 or later + // Remember that usage of defined() in a #define is undefined by the standard. + // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP. + #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64 + #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER + #endif + #endif +#else + // Remember that usage of defined() in a #define is undefined by the standard + #if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_GNUC_AT_LEAST(4,2) ) + #define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC + #endif +#endif + +#ifndef EIGEN_DONT_VECTORIZE + + #if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER) + + // Defines symbols for compile-time detection of which instructions are + // used. + // EIGEN_VECTORIZE_YY is defined if and only if the instruction set YY is used + #define EIGEN_VECTORIZE + #define EIGEN_VECTORIZE_SSE + #define EIGEN_VECTORIZE_SSE2 + + // Detect sse3/ssse3/sse4: + // gcc and icc defines __SSE3__, ... + // there is no way to know about this on msvc. You can define EIGEN_VECTORIZE_SSE* if you + // want to force the use of those instructions with msvc. + #ifdef __SSE3__ + #define EIGEN_VECTORIZE_SSE3 + #endif + #ifdef __SSSE3__ + #define EIGEN_VECTORIZE_SSSE3 + #endif + #ifdef __SSE4_1__ + #define EIGEN_VECTORIZE_SSE4_1 + #endif + #ifdef __SSE4_2__ + #define EIGEN_VECTORIZE_SSE4_2 + #endif + #ifdef __AVX__ + #define EIGEN_VECTORIZE_AVX + #define EIGEN_VECTORIZE_SSE3 + #define EIGEN_VECTORIZE_SSSE3 + #define EIGEN_VECTORIZE_SSE4_1 + #define EIGEN_VECTORIZE_SSE4_2 + #endif + #ifdef __AVX2__ + #define EIGEN_VECTORIZE_AVX2 + #endif + #ifdef __FMA__ + #define EIGEN_VECTORIZE_FMA + #endif + #if defined(__AVX512F__) && defined(EIGEN_ENABLE_AVX512) + #define EIGEN_VECTORIZE_AVX512 + #define EIGEN_VECTORIZE_AVX2 + #define EIGEN_VECTORIZE_AVX + #define EIGEN_VECTORIZE_FMA + #ifdef __AVX512DQ__ + #define EIGEN_VECTORIZE_AVX512DQ + #endif + #ifdef __AVX512ER__ + #define EIGEN_VECTORIZE_AVX512ER + #endif + #endif + + // include files + + // This extern "C" works around a MINGW-w64 compilation issue + // https://sourceforge.net/tracker/index.php?func=detail&aid=3018394&group_id=202880&atid=983354 + // In essence, intrin.h is included by windows.h and also declares intrinsics (just as emmintrin.h etc. below do). + // However, intrin.h uses an extern "C" declaration, and g++ thus complains of duplicate declarations + // with conflicting linkage. The linkage for intrinsics doesn't matter, but at that stage the compiler doesn't know; + // so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern "C" here too. + // notice that since these are C headers, the extern "C" is theoretically needed anyways. + extern "C" { + // In theory we should only include immintrin.h and not the other *mmintrin.h header files directly. + // Doing so triggers some issues with ICC. However old gcc versions seems to not have this file, thus: + #if EIGEN_COMP_ICC >= 1110 + #include + #else + #include + #include + #include + #ifdef EIGEN_VECTORIZE_SSE3 + #include + #endif + #ifdef EIGEN_VECTORIZE_SSSE3 + #include + #endif + #ifdef EIGEN_VECTORIZE_SSE4_1 + #include + #endif + #ifdef EIGEN_VECTORIZE_SSE4_2 + #include + #endif + #if defined(EIGEN_VECTORIZE_AVX) || defined(EIGEN_VECTORIZE_AVX512) + #include + #endif + #endif + } // end extern "C" + #elif defined __VSX__ + #define EIGEN_VECTORIZE + #define EIGEN_VECTORIZE_VSX + #include + // We need to #undef all these ugly tokens defined in + // => use __vector instead of vector + #undef bool + #undef vector + #undef pixel + #elif defined __ALTIVEC__ + #define EIGEN_VECTORIZE + #define EIGEN_VECTORIZE_ALTIVEC + #include + // We need to #undef all these ugly tokens defined in + // => use __vector instead of vector + #undef bool + #undef vector + #undef pixel + #elif (defined __ARM_NEON) || (defined __ARM_NEON__) + #define EIGEN_VECTORIZE + #define EIGEN_VECTORIZE_NEON + #include + #elif (defined __s390x__ && defined __VEC__) + #define EIGEN_VECTORIZE + #define EIGEN_VECTORIZE_ZVECTOR + #include + #endif +#endif + +#if defined(__F16C__) && !defined(EIGEN_COMP_CLANG) + // We can use the optimized fp16 to float and float to fp16 conversion routines + #define EIGEN_HAS_FP16_C +#endif + +#if defined __CUDACC__ + #define EIGEN_VECTORIZE_CUDA + #include + #if EIGEN_CUDACC_VER >= 70500 + #define EIGEN_HAS_CUDA_FP16 + #endif +#endif + +#if defined EIGEN_HAS_CUDA_FP16 + #include + #include +#endif + +#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE) + #define EIGEN_HAS_OPENMP +#endif + +#ifdef EIGEN_HAS_OPENMP +#include +#endif + +// MSVC for windows mobile does not have the errno.h file +#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM +#define EIGEN_HAS_ERRNO +#endif + +#ifdef EIGEN_HAS_ERRNO +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for CHAR_BIT +// for min/max: +#include + +// for std::is_nothrow_move_assignable +#ifdef EIGEN_INCLUDE_TYPE_TRAITS +#include +#endif + +// for outputting debug info +#ifdef EIGEN_DEBUG_ASSIGN +#include +#endif + +// required for __cpuid, needs to be included after cmath +#if EIGEN_COMP_MSVC && EIGEN_ARCH_i386_OR_x86_64 && !EIGEN_OS_WINCE + #include +#endif + +/** \brief Namespace containing all symbols from the %Eigen library. */ +namespace Eigen { + +inline static const char *SimdInstructionSetsInUse(void) { +#if defined(EIGEN_VECTORIZE_AVX512) + return "AVX512, FMA, AVX2, AVX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2"; +#elif defined(EIGEN_VECTORIZE_AVX) + return "AVX SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2"; +#elif defined(EIGEN_VECTORIZE_SSE4_2) + return "SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2"; +#elif defined(EIGEN_VECTORIZE_SSE4_1) + return "SSE, SSE2, SSE3, SSSE3, SSE4.1"; +#elif defined(EIGEN_VECTORIZE_SSSE3) + return "SSE, SSE2, SSE3, SSSE3"; +#elif defined(EIGEN_VECTORIZE_SSE3) + return "SSE, SSE2, SSE3"; +#elif defined(EIGEN_VECTORIZE_SSE2) + return "SSE, SSE2"; +#elif defined(EIGEN_VECTORIZE_ALTIVEC) + return "AltiVec"; +#elif defined(EIGEN_VECTORIZE_VSX) + return "VSX"; +#elif defined(EIGEN_VECTORIZE_NEON) + return "ARM NEON"; +#elif defined(EIGEN_VECTORIZE_ZVECTOR) + return "S390X ZVECTOR"; +#else + return "None"; +#endif +} + +} // end namespace Eigen + +#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API || defined EIGEN2_SUPPORT +// This will generate an error message: +#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information +#endif + +namespace Eigen { + +// we use size_t frequently and we'll never remember to prepend it with std:: everytime just to +// ensure QNX/QCC support +using std::size_t; +// gcc 4.6.0 wants std:: for ptrdiff_t +using std::ptrdiff_t; + +} + +/** \defgroup Core_Module Core module + * This is the main module of Eigen providing dense matrix and vector support + * (both fixed and dynamic size) with all the features corresponding to a BLAS library + * and much more... + * + * \code + * #include + * \endcode + */ + +#include "src/Core/util/Constants.h" +#include "src/Core/util/Meta.h" +#include "src/Core/util/ForwardDeclarations.h" +#include "src/Core/util/StaticAssert.h" +#include "src/Core/util/XprHelper.h" +#include "src/Core/util/Memory.h" + +#include "src/Core/NumTraits.h" +#include "src/Core/MathFunctions.h" +#include "src/Core/GenericPacketMath.h" +#include "src/Core/MathFunctionsImpl.h" +#include "src/Core/arch/Default/ConjHelper.h" + +#if defined EIGEN_VECTORIZE_AVX512 + #include "src/Core/arch/SSE/PacketMath.h" + #include "src/Core/arch/AVX/PacketMath.h" + #include "src/Core/arch/AVX512/PacketMath.h" + #include "src/Core/arch/AVX512/MathFunctions.h" +#elif defined EIGEN_VECTORIZE_AVX + // Use AVX for floats and doubles, SSE for integers + #include "src/Core/arch/SSE/PacketMath.h" + #include "src/Core/arch/SSE/Complex.h" + #include "src/Core/arch/SSE/MathFunctions.h" + #include "src/Core/arch/AVX/PacketMath.h" + #include "src/Core/arch/AVX/MathFunctions.h" + #include "src/Core/arch/AVX/Complex.h" + #include "src/Core/arch/AVX/TypeCasting.h" + #include "src/Core/arch/SSE/TypeCasting.h" +#elif defined EIGEN_VECTORIZE_SSE + #include "src/Core/arch/SSE/PacketMath.h" + #include "src/Core/arch/SSE/MathFunctions.h" + #include "src/Core/arch/SSE/Complex.h" + #include "src/Core/arch/SSE/TypeCasting.h" +#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX) + #include "src/Core/arch/AltiVec/PacketMath.h" + #include "src/Core/arch/AltiVec/MathFunctions.h" + #include "src/Core/arch/AltiVec/Complex.h" +#elif defined EIGEN_VECTORIZE_NEON + #include "src/Core/arch/NEON/PacketMath.h" + #include "src/Core/arch/NEON/MathFunctions.h" + #include "src/Core/arch/NEON/Complex.h" +#elif defined EIGEN_VECTORIZE_ZVECTOR + #include "src/Core/arch/ZVector/PacketMath.h" + #include "src/Core/arch/ZVector/MathFunctions.h" + #include "src/Core/arch/ZVector/Complex.h" +#endif + +// Half float support +#include "src/Core/arch/CUDA/Half.h" +#include "src/Core/arch/CUDA/PacketMathHalf.h" +#include "src/Core/arch/CUDA/TypeCasting.h" + +#if defined EIGEN_VECTORIZE_CUDA + #include "src/Core/arch/CUDA/PacketMath.h" + #include "src/Core/arch/CUDA/MathFunctions.h" +#endif + +#include "src/Core/arch/Default/Settings.h" + +#include "src/Core/functors/TernaryFunctors.h" +#include "src/Core/functors/BinaryFunctors.h" +#include "src/Core/functors/UnaryFunctors.h" +#include "src/Core/functors/NullaryFunctors.h" +#include "src/Core/functors/StlFunctors.h" +#include "src/Core/functors/AssignmentFunctors.h" + +// Specialized functors to enable the processing of complex numbers +// on CUDA devices +#include "src/Core/arch/CUDA/Complex.h" + +#include "src/Core/IO.h" +#include "src/Core/DenseCoeffsBase.h" +#include "src/Core/DenseBase.h" +#include "src/Core/MatrixBase.h" +#include "src/Core/EigenBase.h" + +#include "src/Core/Product.h" +#include "src/Core/CoreEvaluators.h" +#include "src/Core/AssignEvaluator.h" + +#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874 + // at least confirmed with Doxygen 1.5.5 and 1.5.6 + #include "src/Core/Assign.h" +#endif + +#include "src/Core/ArrayBase.h" +#include "src/Core/util/BlasUtil.h" +#include "src/Core/DenseStorage.h" +#include "src/Core/NestByValue.h" + +// #include "src/Core/ForceAlignedAccess.h" + +#include "src/Core/ReturnByValue.h" +#include "src/Core/NoAlias.h" +#include "src/Core/PlainObjectBase.h" +#include "src/Core/Matrix.h" +#include "src/Core/Array.h" +#include "src/Core/CwiseTernaryOp.h" +#include "src/Core/CwiseBinaryOp.h" +#include "src/Core/CwiseUnaryOp.h" +#include "src/Core/CwiseNullaryOp.h" +#include "src/Core/CwiseUnaryView.h" +#include "src/Core/SelfCwiseBinaryOp.h" +#include "src/Core/Dot.h" +#include "src/Core/StableNorm.h" +#include "src/Core/Stride.h" +#include "src/Core/MapBase.h" +#include "src/Core/Map.h" +#include "src/Core/Ref.h" +#include "src/Core/Block.h" +#include "src/Core/VectorBlock.h" +#include "src/Core/Transpose.h" +#include "src/Core/DiagonalMatrix.h" +#include "src/Core/Diagonal.h" +#include "src/Core/DiagonalProduct.h" +#include "src/Core/Redux.h" +#include "src/Core/Visitor.h" +#include "src/Core/Fuzzy.h" +#include "src/Core/Swap.h" +#include "src/Core/CommaInitializer.h" +#include "src/Core/GeneralProduct.h" +#include "src/Core/Solve.h" +#include "src/Core/Inverse.h" +#include "src/Core/SolverBase.h" +#include "src/Core/PermutationMatrix.h" +#include "src/Core/Transpositions.h" +#include "src/Core/TriangularMatrix.h" +#include "src/Core/SelfAdjointView.h" +#include "src/Core/products/GeneralBlockPanelKernel.h" +#include "src/Core/products/Parallelizer.h" +#include "src/Core/ProductEvaluators.h" +#include "src/Core/products/GeneralMatrixVector.h" +#include "src/Core/products/GeneralMatrixMatrix.h" +#include "src/Core/SolveTriangular.h" +#include "src/Core/products/GeneralMatrixMatrixTriangular.h" +#include "src/Core/products/SelfadjointMatrixVector.h" +#include "src/Core/products/SelfadjointMatrixMatrix.h" +#include "src/Core/products/SelfadjointProduct.h" +#include "src/Core/products/SelfadjointRank2Update.h" +#include "src/Core/products/TriangularMatrixVector.h" +#include "src/Core/products/TriangularMatrixMatrix.h" +#include "src/Core/products/TriangularSolverMatrix.h" +#include "src/Core/products/TriangularSolverVector.h" +#include "src/Core/BandMatrix.h" +#include "src/Core/CoreIterators.h" +#include "src/Core/ConditionEstimator.h" + +#include "src/Core/BooleanRedux.h" +#include "src/Core/Select.h" +#include "src/Core/VectorwiseOp.h" +#include "src/Core/Random.h" +#include "src/Core/Replicate.h" +#include "src/Core/Reverse.h" +#include "src/Core/ArrayWrapper.h" + +#ifdef EIGEN_USE_BLAS +#include "src/Core/products/GeneralMatrixMatrix_BLAS.h" +#include "src/Core/products/GeneralMatrixVector_BLAS.h" +#include "src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h" +#include "src/Core/products/SelfadjointMatrixMatrix_BLAS.h" +#include "src/Core/products/SelfadjointMatrixVector_BLAS.h" +#include "src/Core/products/TriangularMatrixMatrix_BLAS.h" +#include "src/Core/products/TriangularMatrixVector_BLAS.h" +#include "src/Core/products/TriangularSolverMatrix_BLAS.h" +#endif // EIGEN_USE_BLAS + +#ifdef EIGEN_USE_MKL_VML +#include "src/Core/Assign_MKL.h" +#endif + +#include "src/Core/GlobalFunctions.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_CORE_H diff --git a/3rdparty/eigen3/Eigen/Dense b/3rdparty/eigen3/Eigen/Dense new file mode 100644 index 0000000..5768910 --- /dev/null +++ b/3rdparty/eigen3/Eigen/Dense @@ -0,0 +1,7 @@ +#include "Core" +#include "LU" +#include "Cholesky" +#include "QR" +#include "SVD" +#include "Geometry" +#include "Eigenvalues" diff --git a/3rdparty/eigen3/Eigen/Eigen b/3rdparty/eigen3/Eigen/Eigen new file mode 100644 index 0000000..654c8dc --- /dev/null +++ b/3rdparty/eigen3/Eigen/Eigen @@ -0,0 +1,2 @@ +#include "Dense" +#include "Sparse" diff --git a/3rdparty/eigen3/Eigen/Eigenvalues b/3rdparty/eigen3/Eigen/Eigenvalues new file mode 100644 index 0000000..f3f661b --- /dev/null +++ b/3rdparty/eigen3/Eigen/Eigenvalues @@ -0,0 +1,61 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_EIGENVALUES_MODULE_H +#define EIGEN_EIGENVALUES_MODULE_H + +#include "Core" + +#include "src/Core/util/DisableStupidWarnings.h" + +#include "Cholesky" +#include "Jacobi" +#include "Householder" +#include "LU" +#include "Geometry" + +/** \defgroup Eigenvalues_Module Eigenvalues module + * + * + * + * This module mainly provides various eigenvalue solvers. + * This module also provides some MatrixBase methods, including: + * - MatrixBase::eigenvalues(), + * - MatrixBase::operatorNorm() + * + * \code + * #include + * \endcode + */ + +#include "src/misc/RealSvd2x2.h" +#include "src/Eigenvalues/Tridiagonalization.h" +#include "src/Eigenvalues/RealSchur.h" +#include "src/Eigenvalues/EigenSolver.h" +#include "src/Eigenvalues/SelfAdjointEigenSolver.h" +#include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h" +#include "src/Eigenvalues/HessenbergDecomposition.h" +#include "src/Eigenvalues/ComplexSchur.h" +#include "src/Eigenvalues/ComplexEigenSolver.h" +#include "src/Eigenvalues/RealQZ.h" +#include "src/Eigenvalues/GeneralizedEigenSolver.h" +#include "src/Eigenvalues/MatrixBaseEigenvalues.h" +#ifdef EIGEN_USE_LAPACKE +#ifdef EIGEN_USE_MKL +#include "mkl_lapacke.h" +#else +#include "src/misc/lapacke.h" +#endif +#include "src/Eigenvalues/RealSchur_LAPACKE.h" +#include "src/Eigenvalues/ComplexSchur_LAPACKE.h" +#include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h" +#endif + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_EIGENVALUES_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ diff --git a/3rdparty/eigen3/Eigen/Geometry b/3rdparty/eigen3/Eigen/Geometry new file mode 100644 index 0000000..716d529 --- /dev/null +++ b/3rdparty/eigen3/Eigen/Geometry @@ -0,0 +1,62 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_GEOMETRY_MODULE_H +#define EIGEN_GEOMETRY_MODULE_H + +#include "Core" + +#include "src/Core/util/DisableStupidWarnings.h" + +#include "SVD" +#include "LU" +#include + +/** \defgroup Geometry_Module Geometry module + * + * This module provides support for: + * - fixed-size homogeneous transformations + * - translation, scaling, 2D and 3D rotations + * - \link Quaternion quaternions \endlink + * - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3) + * - orthognal vector generation (\ref MatrixBase::unitOrthogonal) + * - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink + * - \link AlignedBox axis aligned bounding boxes \endlink + * - \link umeyama least-square transformation fitting \endlink + * + * \code + * #include + * \endcode + */ + +#include "src/Geometry/OrthoMethods.h" +#include "src/Geometry/EulerAngles.h" + +#include "src/Geometry/Homogeneous.h" +#include "src/Geometry/RotationBase.h" +#include "src/Geometry/Rotation2D.h" +#include "src/Geometry/Quaternion.h" +#include "src/Geometry/AngleAxis.h" +#include "src/Geometry/Transform.h" +#include "src/Geometry/Translation.h" +#include "src/Geometry/Scaling.h" +#include "src/Geometry/Hyperplane.h" +#include "src/Geometry/ParametrizedLine.h" +#include "src/Geometry/AlignedBox.h" +#include "src/Geometry/Umeyama.h" + +// Use the SSE optimized version whenever possible. At the moment the +// SSE version doesn't compile when AVX is enabled +#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX +#include "src/Geometry/arch/Geometry_SSE.h" +#endif + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_GEOMETRY_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ + diff --git a/3rdparty/eigen3/Eigen/Householder b/3rdparty/eigen3/Eigen/Householder new file mode 100644 index 0000000..89cd81b --- /dev/null +++ b/3rdparty/eigen3/Eigen/Householder @@ -0,0 +1,30 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_HOUSEHOLDER_MODULE_H +#define EIGEN_HOUSEHOLDER_MODULE_H + +#include "Core" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** \defgroup Householder_Module Householder module + * This module provides Householder transformations. + * + * \code + * #include + * \endcode + */ + +#include "src/Householder/Householder.h" +#include "src/Householder/HouseholderSequence.h" +#include "src/Householder/BlockHouseholder.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_HOUSEHOLDER_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ diff --git a/3rdparty/eigen3/Eigen/IterativeLinearSolvers b/3rdparty/eigen3/Eigen/IterativeLinearSolvers new file mode 100644 index 0000000..957d575 --- /dev/null +++ b/3rdparty/eigen3/Eigen/IterativeLinearSolvers @@ -0,0 +1,48 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H +#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H + +#include "SparseCore" +#include "OrderingMethods" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** + * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module + * + * This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse. + * Those solvers are accessible via the following classes: + * - ConjugateGradient for selfadjoint (hermitian) matrices, + * - LeastSquaresConjugateGradient for rectangular least-square problems, + * - BiCGSTAB for general square matrices. + * + * These iterative solvers are associated with some preconditioners: + * - IdentityPreconditioner - not really useful + * - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices. + * - IncompleteLUT - incomplete LU factorization with dual thresholding + * + * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport. + * + \code + #include + \endcode + */ + +#include "src/IterativeLinearSolvers/SolveWithGuess.h" +#include "src/IterativeLinearSolvers/IterativeSolverBase.h" +#include "src/IterativeLinearSolvers/BasicPreconditioners.h" +#include "src/IterativeLinearSolvers/ConjugateGradient.h" +#include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h" +#include "src/IterativeLinearSolvers/BiCGSTAB.h" +#include "src/IterativeLinearSolvers/IncompleteLUT.h" +#include "src/IterativeLinearSolvers/IncompleteCholesky.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H diff --git a/3rdparty/eigen3/Eigen/Jacobi b/3rdparty/eigen3/Eigen/Jacobi new file mode 100644 index 0000000..17c1d78 --- /dev/null +++ b/3rdparty/eigen3/Eigen/Jacobi @@ -0,0 +1,33 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_JACOBI_MODULE_H +#define EIGEN_JACOBI_MODULE_H + +#include "Core" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** \defgroup Jacobi_Module Jacobi module + * This module provides Jacobi and Givens rotations. + * + * \code + * #include + * \endcode + * + * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation: + * - MatrixBase::applyOnTheLeft() + * - MatrixBase::applyOnTheRight(). + */ + +#include "src/Jacobi/Jacobi.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_JACOBI_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ + diff --git a/3rdparty/eigen3/Eigen/LU b/3rdparty/eigen3/Eigen/LU new file mode 100644 index 0000000..6418a86 --- /dev/null +++ b/3rdparty/eigen3/Eigen/LU @@ -0,0 +1,50 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_LU_MODULE_H +#define EIGEN_LU_MODULE_H + +#include "Core" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** \defgroup LU_Module LU module + * This module includes %LU decomposition and related notions such as matrix inversion and determinant. + * This module defines the following MatrixBase methods: + * - MatrixBase::inverse() + * - MatrixBase::determinant() + * + * \code + * #include + * \endcode + */ + +#include "src/misc/Kernel.h" +#include "src/misc/Image.h" +#include "src/LU/FullPivLU.h" +#include "src/LU/PartialPivLU.h" +#ifdef EIGEN_USE_LAPACKE +#ifdef EIGEN_USE_MKL +#include "mkl_lapacke.h" +#else +#include "src/misc/lapacke.h" +#endif +#include "src/LU/PartialPivLU_LAPACKE.h" +#endif +#include "src/LU/Determinant.h" +#include "src/LU/InverseImpl.h" + +// Use the SSE optimized version whenever possible. At the moment the +// SSE version doesn't compile when AVX is enabled +#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX + #include "src/LU/arch/Inverse_SSE.h" +#endif + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_LU_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ diff --git a/3rdparty/eigen3/Eigen/MetisSupport b/3rdparty/eigen3/Eigen/MetisSupport new file mode 100644 index 0000000..85c41bf --- /dev/null +++ b/3rdparty/eigen3/Eigen/MetisSupport @@ -0,0 +1,35 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_METISSUPPORT_MODULE_H +#define EIGEN_METISSUPPORT_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +extern "C" { +#include +} + + +/** \ingroup Support_modules + * \defgroup MetisSupport_Module MetisSupport module + * + * \code + * #include + * \endcode + * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). + * It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink + */ + + +#include "src/MetisSupport/MetisSupport.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_METISSUPPORT_MODULE_H diff --git a/3rdparty/eigen3/Eigen/OrderingMethods b/3rdparty/eigen3/Eigen/OrderingMethods new file mode 100644 index 0000000..d8ea361 --- /dev/null +++ b/3rdparty/eigen3/Eigen/OrderingMethods @@ -0,0 +1,73 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ORDERINGMETHODS_MODULE_H +#define EIGEN_ORDERINGMETHODS_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** + * \defgroup OrderingMethods_Module OrderingMethods module + * + * This module is currently for internal use only + * + * It defines various built-in and external ordering methods for sparse matrices. + * They are typically used to reduce the number of elements during + * the sparse matrix decomposition (LLT, LU, QR). + * Precisely, in a preprocessing step, a permutation matrix P is computed using + * those ordering methods and applied to the columns of the matrix. + * Using for instance the sparse Cholesky decomposition, it is expected that + * the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A). + * + * + * Usage : + * \code + * #include + * \endcode + * + * A simple usage is as a template parameter in the sparse decomposition classes : + * + * \code + * SparseLU > solver; + * \endcode + * + * \code + * SparseQR > solver; + * \endcode + * + * It is possible as well to call directly a particular ordering method for your own purpose, + * \code + * AMDOrdering ordering; + * PermutationMatrix perm; + * SparseMatrix A; + * //Fill the matrix ... + * + * ordering(A, perm); // Call AMD + * \endcode + * + * \note Some of these methods (like AMD or METIS), need the sparsity pattern + * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, + * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method. + * If your matrix is already symmetric (at leat in structure), you can avoid that + * by calling the method with a SelfAdjointView type. + * + * \code + * // Call the ordering on the pattern of the lower triangular matrix A + * ordering(A.selfadjointView(), perm); + * \endcode + */ + +#ifndef EIGEN_MPL2_ONLY +#include "src/OrderingMethods/Amd.h" +#endif + +#include "src/OrderingMethods/Ordering.h" +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_ORDERINGMETHODS_MODULE_H diff --git a/3rdparty/eigen3/Eigen/PaStiXSupport b/3rdparty/eigen3/Eigen/PaStiXSupport new file mode 100644 index 0000000..de3a63b --- /dev/null +++ b/3rdparty/eigen3/Eigen/PaStiXSupport @@ -0,0 +1,48 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_PASTIXSUPPORT_MODULE_H +#define EIGEN_PASTIXSUPPORT_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +extern "C" { +#include +#include +} + +#ifdef complex +#undef complex +#endif + +/** \ingroup Support_modules + * \defgroup PaStiXSupport_Module PaStiXSupport module + * + * This module provides an interface to the PaSTiX library. + * PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver. + * It provides the two following main factorization classes: + * - class PastixLLT : a supernodal, parallel LLt Cholesky factorization. + * - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization. + * - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern). + * + * \code + * #include + * \endcode + * + * In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies. + * The dependencies depend on how PaSTiX has been compiled. + * For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task. + * + */ + +#include "src/PaStiXSupport/PaStiXSupport.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_PASTIXSUPPORT_MODULE_H diff --git a/3rdparty/eigen3/Eigen/PardisoSupport b/3rdparty/eigen3/Eigen/PardisoSupport new file mode 100755 index 0000000..340edf5 --- /dev/null +++ b/3rdparty/eigen3/Eigen/PardisoSupport @@ -0,0 +1,35 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_PARDISOSUPPORT_MODULE_H +#define EIGEN_PARDISOSUPPORT_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +#include + +/** \ingroup Support_modules + * \defgroup PardisoSupport_Module PardisoSupport module + * + * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers. + * + * \code + * #include + * \endcode + * + * In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies. + * See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration. + * + */ + +#include "src/PardisoSupport/PardisoSupport.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_PARDISOSUPPORT_MODULE_H diff --git a/3rdparty/eigen3/Eigen/QR b/3rdparty/eigen3/Eigen/QR new file mode 100644 index 0000000..c7e9144 --- /dev/null +++ b/3rdparty/eigen3/Eigen/QR @@ -0,0 +1,51 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_QR_MODULE_H +#define EIGEN_QR_MODULE_H + +#include "Core" + +#include "src/Core/util/DisableStupidWarnings.h" + +#include "Cholesky" +#include "Jacobi" +#include "Householder" + +/** \defgroup QR_Module QR module + * + * + * + * This module provides various QR decompositions + * This module also provides some MatrixBase methods, including: + * - MatrixBase::householderQr() + * - MatrixBase::colPivHouseholderQr() + * - MatrixBase::fullPivHouseholderQr() + * + * \code + * #include + * \endcode + */ + +#include "src/QR/HouseholderQR.h" +#include "src/QR/FullPivHouseholderQR.h" +#include "src/QR/ColPivHouseholderQR.h" +#include "src/QR/CompleteOrthogonalDecomposition.h" +#ifdef EIGEN_USE_LAPACKE +#ifdef EIGEN_USE_MKL +#include "mkl_lapacke.h" +#else +#include "src/misc/lapacke.h" +#endif +#include "src/QR/HouseholderQR_LAPACKE.h" +#include "src/QR/ColPivHouseholderQR_LAPACKE.h" +#endif + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_QR_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ diff --git a/3rdparty/eigen3/Eigen/QtAlignedMalloc b/3rdparty/eigen3/Eigen/QtAlignedMalloc new file mode 100644 index 0000000..4f07df0 --- /dev/null +++ b/3rdparty/eigen3/Eigen/QtAlignedMalloc @@ -0,0 +1,40 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_QTMALLOC_MODULE_H +#define EIGEN_QTMALLOC_MODULE_H + +#include "Core" + +#if (!EIGEN_MALLOC_ALREADY_ALIGNED) + +#include "src/Core/util/DisableStupidWarnings.h" + +void *qMalloc(std::size_t size) +{ + return Eigen::internal::aligned_malloc(size); +} + +void qFree(void *ptr) +{ + Eigen::internal::aligned_free(ptr); +} + +void *qRealloc(void *ptr, std::size_t size) +{ + void* newPtr = Eigen::internal::aligned_malloc(size); + std::memcpy(newPtr, ptr, size); + Eigen::internal::aligned_free(ptr); + return newPtr; +} + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif + +#endif // EIGEN_QTMALLOC_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ diff --git a/3rdparty/eigen3/Eigen/SPQRSupport b/3rdparty/eigen3/Eigen/SPQRSupport new file mode 100644 index 0000000..f70390c --- /dev/null +++ b/3rdparty/eigen3/Eigen/SPQRSupport @@ -0,0 +1,34 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SPQRSUPPORT_MODULE_H +#define EIGEN_SPQRSUPPORT_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +#include "SuiteSparseQR.hpp" + +/** \ingroup Support_modules + * \defgroup SPQRSupport_Module SuiteSparseQR module + * + * This module provides an interface to the SPQR library, which is part of the suitesparse package. + * + * \code + * #include + * \endcode + * + * In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...). + * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules + * + */ + +#include "src/CholmodSupport/CholmodSupport.h" +#include "src/SPQRSupport/SuiteSparseQRSupport.h" + +#endif diff --git a/3rdparty/eigen3/Eigen/SVD b/3rdparty/eigen3/Eigen/SVD new file mode 100644 index 0000000..5d0e75f --- /dev/null +++ b/3rdparty/eigen3/Eigen/SVD @@ -0,0 +1,51 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SVD_MODULE_H +#define EIGEN_SVD_MODULE_H + +#include "QR" +#include "Householder" +#include "Jacobi" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** \defgroup SVD_Module SVD module + * + * + * + * This module provides SVD decomposition for matrices (both real and complex). + * Two decomposition algorithms are provided: + * - JacobiSVD implementing two-sided Jacobi iterations is numerically very accurate, fast for small matrices, but very slow for larger ones. + * - BDCSVD implementing a recursive divide & conquer strategy on top of an upper-bidiagonalization which remains fast for large problems. + * These decompositions are accessible via the respective classes and following MatrixBase methods: + * - MatrixBase::jacobiSvd() + * - MatrixBase::bdcSvd() + * + * \code + * #include + * \endcode + */ + +#include "src/misc/RealSvd2x2.h" +#include "src/SVD/UpperBidiagonalization.h" +#include "src/SVD/SVDBase.h" +#include "src/SVD/JacobiSVD.h" +#include "src/SVD/BDCSVD.h" +#if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) +#ifdef EIGEN_USE_MKL +#include "mkl_lapacke.h" +#else +#include "src/misc/lapacke.h" +#endif +#include "src/SVD/JacobiSVD_LAPACKE.h" +#endif + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_SVD_MODULE_H +/* vim: set filetype=cpp et sw=2 ts=2 ai: */ diff --git a/3rdparty/eigen3/Eigen/Sparse b/3rdparty/eigen3/Eigen/Sparse new file mode 100644 index 0000000..136e681 --- /dev/null +++ b/3rdparty/eigen3/Eigen/Sparse @@ -0,0 +1,36 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SPARSE_MODULE_H +#define EIGEN_SPARSE_MODULE_H + +/** \defgroup Sparse_Module Sparse meta-module + * + * Meta-module including all related modules: + * - \ref SparseCore_Module + * - \ref OrderingMethods_Module + * - \ref SparseCholesky_Module + * - \ref SparseLU_Module + * - \ref SparseQR_Module + * - \ref IterativeLinearSolvers_Module + * + \code + #include + \endcode + */ + +#include "SparseCore" +#include "OrderingMethods" +#ifndef EIGEN_MPL2_ONLY +#include "SparseCholesky" +#endif +#include "SparseLU" +#include "SparseQR" +#include "IterativeLinearSolvers" + +#endif // EIGEN_SPARSE_MODULE_H + diff --git a/3rdparty/eigen3/Eigen/SparseCholesky b/3rdparty/eigen3/Eigen/SparseCholesky new file mode 100644 index 0000000..b6a320c --- /dev/null +++ b/3rdparty/eigen3/Eigen/SparseCholesky @@ -0,0 +1,45 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2013 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SPARSECHOLESKY_MODULE_H +#define EIGEN_SPARSECHOLESKY_MODULE_H + +#include "SparseCore" +#include "OrderingMethods" + +#include "src/Core/util/DisableStupidWarnings.h" + +/** + * \defgroup SparseCholesky_Module SparseCholesky module + * + * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices. + * Those decompositions are accessible via the following classes: + * - SimplicialLLt, + * - SimplicialLDLt + * + * Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module. + * + * \code + * #include + * \endcode + */ + +#ifdef EIGEN_MPL2_ONLY +#error The SparseCholesky module has nothing to offer in MPL2 only mode +#endif + +#include "src/SparseCholesky/SimplicialCholesky.h" + +#ifndef EIGEN_MPL2_ONLY +#include "src/SparseCholesky/SimplicialCholesky_impl.h" +#endif + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_SPARSECHOLESKY_MODULE_H diff --git a/3rdparty/eigen3/Eigen/SparseCore b/3rdparty/eigen3/Eigen/SparseCore new file mode 100644 index 0000000..76966c4 --- /dev/null +++ b/3rdparty/eigen3/Eigen/SparseCore @@ -0,0 +1,69 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SPARSECORE_MODULE_H +#define EIGEN_SPARSECORE_MODULE_H + +#include "Core" + +#include "src/Core/util/DisableStupidWarnings.h" + +#include +#include +#include +#include +#include + +/** + * \defgroup SparseCore_Module SparseCore module + * + * This module provides a sparse matrix representation, and basic associated matrix manipulations + * and operations. + * + * See the \ref TutorialSparse "Sparse tutorial" + * + * \code + * #include + * \endcode + * + * This module depends on: Core. + */ + +#include "src/SparseCore/SparseUtil.h" +#include "src/SparseCore/SparseMatrixBase.h" +#include "src/SparseCore/SparseAssign.h" +#include "src/SparseCore/CompressedStorage.h" +#include "src/SparseCore/AmbiVector.h" +#include "src/SparseCore/SparseCompressedBase.h" +#include "src/SparseCore/SparseMatrix.h" +#include "src/SparseCore/SparseMap.h" +#include "src/SparseCore/MappedSparseMatrix.h" +#include "src/SparseCore/SparseVector.h" +#include "src/SparseCore/SparseRef.h" +#include "src/SparseCore/SparseCwiseUnaryOp.h" +#include "src/SparseCore/SparseCwiseBinaryOp.h" +#include "src/SparseCore/SparseTranspose.h" +#include "src/SparseCore/SparseBlock.h" +#include "src/SparseCore/SparseDot.h" +#include "src/SparseCore/SparseRedux.h" +#include "src/SparseCore/SparseView.h" +#include "src/SparseCore/SparseDiagonalProduct.h" +#include "src/SparseCore/ConservativeSparseSparseProduct.h" +#include "src/SparseCore/SparseSparseProductWithPruning.h" +#include "src/SparseCore/SparseProduct.h" +#include "src/SparseCore/SparseDenseProduct.h" +#include "src/SparseCore/SparseSelfAdjointView.h" +#include "src/SparseCore/SparseTriangularView.h" +#include "src/SparseCore/TriangularSolver.h" +#include "src/SparseCore/SparsePermutation.h" +#include "src/SparseCore/SparseFuzzy.h" +#include "src/SparseCore/SparseSolverBase.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_SPARSECORE_MODULE_H + diff --git a/3rdparty/eigen3/Eigen/SparseLU b/3rdparty/eigen3/Eigen/SparseLU new file mode 100644 index 0000000..38b38b5 --- /dev/null +++ b/3rdparty/eigen3/Eigen/SparseLU @@ -0,0 +1,46 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2012 Désiré Nuentsa-Wakam +// Copyright (C) 2012 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SPARSELU_MODULE_H +#define EIGEN_SPARSELU_MODULE_H + +#include "SparseCore" + +/** + * \defgroup SparseLU_Module SparseLU module + * This module defines a supernodal factorization of general sparse matrices. + * The code is fully optimized for supernode-panel updates with specialized kernels. + * Please, see the documentation of the SparseLU class for more details. + */ + +// Ordering interface +#include "OrderingMethods" + +#include "src/SparseLU/SparseLU_gemm_kernel.h" + +#include "src/SparseLU/SparseLU_Structs.h" +#include "src/SparseLU/SparseLU_SupernodalMatrix.h" +#include "src/SparseLU/SparseLUImpl.h" +#include "src/SparseCore/SparseColEtree.h" +#include "src/SparseLU/SparseLU_Memory.h" +#include "src/SparseLU/SparseLU_heap_relax_snode.h" +#include "src/SparseLU/SparseLU_relax_snode.h" +#include "src/SparseLU/SparseLU_pivotL.h" +#include "src/SparseLU/SparseLU_panel_dfs.h" +#include "src/SparseLU/SparseLU_kernel_bmod.h" +#include "src/SparseLU/SparseLU_panel_bmod.h" +#include "src/SparseLU/SparseLU_column_dfs.h" +#include "src/SparseLU/SparseLU_column_bmod.h" +#include "src/SparseLU/SparseLU_copy_to_ucol.h" +#include "src/SparseLU/SparseLU_pruneL.h" +#include "src/SparseLU/SparseLU_Utils.h" +#include "src/SparseLU/SparseLU.h" + +#endif // EIGEN_SPARSELU_MODULE_H diff --git a/3rdparty/eigen3/Eigen/SparseQR b/3rdparty/eigen3/Eigen/SparseQR new file mode 100644 index 0000000..a6f3b7f --- /dev/null +++ b/3rdparty/eigen3/Eigen/SparseQR @@ -0,0 +1,37 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SPARSEQR_MODULE_H +#define EIGEN_SPARSEQR_MODULE_H + +#include "SparseCore" +#include "OrderingMethods" +#include "src/Core/util/DisableStupidWarnings.h" + +/** \defgroup SparseQR_Module SparseQR module + * \brief Provides QR decomposition for sparse matrices + * + * This module provides a simplicial version of the left-looking Sparse QR decomposition. + * The columns of the input matrix should be reordered to limit the fill-in during the + * decomposition. Built-in methods (COLAMD, AMD) or external methods (METIS) can be used to this end. + * See the \link OrderingMethods_Module OrderingMethods\endlink module for the list + * of built-in and external ordering methods. + * + * \code + * #include + * \endcode + * + * + */ + +#include "OrderingMethods" +#include "src/SparseCore/SparseColEtree.h" +#include "src/SparseQR/SparseQR.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif diff --git a/3rdparty/eigen3/Eigen/StdDeque b/3rdparty/eigen3/Eigen/StdDeque new file mode 100644 index 0000000..bc68397 --- /dev/null +++ b/3rdparty/eigen3/Eigen/StdDeque @@ -0,0 +1,27 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// Copyright (C) 2009 Hauke Heibel +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_STDDEQUE_MODULE_H +#define EIGEN_STDDEQUE_MODULE_H + +#include "Core" +#include + +#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */ + +#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) + +#else + +#include "src/StlSupport/StdDeque.h" + +#endif + +#endif // EIGEN_STDDEQUE_MODULE_H diff --git a/3rdparty/eigen3/Eigen/StdList b/3rdparty/eigen3/Eigen/StdList new file mode 100644 index 0000000..4c6262c --- /dev/null +++ b/3rdparty/eigen3/Eigen/StdList @@ -0,0 +1,26 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Hauke Heibel +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_STDLIST_MODULE_H +#define EIGEN_STDLIST_MODULE_H + +#include "Core" +#include + +#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */ + +#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) + +#else + +#include "src/StlSupport/StdList.h" + +#endif + +#endif // EIGEN_STDLIST_MODULE_H diff --git a/3rdparty/eigen3/Eigen/StdVector b/3rdparty/eigen3/Eigen/StdVector new file mode 100644 index 0000000..0c4697a --- /dev/null +++ b/3rdparty/eigen3/Eigen/StdVector @@ -0,0 +1,27 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// Copyright (C) 2009 Hauke Heibel +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_STDVECTOR_MODULE_H +#define EIGEN_STDVECTOR_MODULE_H + +#include "Core" +#include + +#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */ + +#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) + +#else + +#include "src/StlSupport/StdVector.h" + +#endif + +#endif // EIGEN_STDVECTOR_MODULE_H diff --git a/3rdparty/eigen3/Eigen/SuperLUSupport b/3rdparty/eigen3/Eigen/SuperLUSupport new file mode 100644 index 0000000..59312a8 --- /dev/null +++ b/3rdparty/eigen3/Eigen/SuperLUSupport @@ -0,0 +1,64 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SUPERLUSUPPORT_MODULE_H +#define EIGEN_SUPERLUSUPPORT_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +#ifdef EMPTY +#define EIGEN_EMPTY_WAS_ALREADY_DEFINED +#endif + +typedef int int_t; +#include +#include +#include + +// slu_util.h defines a preprocessor token named EMPTY which is really polluting, +// so we remove it in favor of a SUPERLU_EMPTY token. +// If EMPTY was already defined then we don't undef it. + +#if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED) +# undef EIGEN_EMPTY_WAS_ALREADY_DEFINED +#elif defined(EMPTY) +# undef EMPTY +#endif + +#define SUPERLU_EMPTY (-1) + +namespace Eigen { struct SluMatrix; } + +/** \ingroup Support_modules + * \defgroup SuperLUSupport_Module SuperLUSupport module + * + * This module provides an interface to the SuperLU library. + * It provides the following factorization class: + * - class SuperLU: a supernodal sequential LU factorization. + * - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods). + * + * \warning This wrapper requires at least versions 4.0 of SuperLU. The 3.x versions are not supported. + * + * \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting. + * + * \code + * #include + * \endcode + * + * In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies. + * The dependencies depend on how superlu has been compiled. + * For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task. + * + */ + +#include "src/SuperLUSupport/SuperLUSupport.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_SUPERLUSUPPORT_MODULE_H diff --git a/3rdparty/eigen3/Eigen/UmfPackSupport b/3rdparty/eigen3/Eigen/UmfPackSupport new file mode 100644 index 0000000..00eec80 --- /dev/null +++ b/3rdparty/eigen3/Eigen/UmfPackSupport @@ -0,0 +1,40 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_UMFPACKSUPPORT_MODULE_H +#define EIGEN_UMFPACKSUPPORT_MODULE_H + +#include "SparseCore" + +#include "src/Core/util/DisableStupidWarnings.h" + +extern "C" { +#include +} + +/** \ingroup Support_modules + * \defgroup UmfPackSupport_Module UmfPackSupport module + * + * This module provides an interface to the UmfPack library which is part of the suitesparse package. + * It provides the following factorization class: + * - class UmfPackLU: a multifrontal sequential LU factorization. + * + * \code + * #include + * \endcode + * + * In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies. + * The dependencies depend on how umfpack has been compiled. + * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task. + * + */ + +#include "src/UmfPackSupport/UmfPackSupport.h" + +#include "src/Core/util/ReenableStupidWarnings.h" + +#endif // EIGEN_UMFPACKSUPPORT_MODULE_H diff --git a/3rdparty/eigen3/Eigen/src/Cholesky/LDLT.h b/3rdparty/eigen3/Eigen/src/Cholesky/LDLT.h new file mode 100644 index 0000000..0313a54 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Cholesky/LDLT.h @@ -0,0 +1,672 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2011 Gael Guennebaud +// Copyright (C) 2009 Keir Mierle +// Copyright (C) 2009 Benoit Jacob +// Copyright (C) 2011 Timothy E. Holy +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_LDLT_H +#define EIGEN_LDLT_H + +namespace Eigen { + +namespace internal { + template struct LDLT_Traits; + + // PositiveSemiDef means positive semi-definite and non-zero; same for NegativeSemiDef + enum SignMatrix { PositiveSemiDef, NegativeSemiDef, ZeroSign, Indefinite }; +} + +/** \ingroup Cholesky_Module + * + * \class LDLT + * + * \brief Robust Cholesky decomposition of a matrix with pivoting + * + * \tparam _MatrixType the type of the matrix of which to compute the LDL^T Cholesky decomposition + * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper. + * The other triangular part won't be read. + * + * Perform a robust Cholesky decomposition of a positive semidefinite or negative semidefinite + * matrix \f$ A \f$ such that \f$ A = P^TLDL^*P \f$, where P is a permutation matrix, L + * is lower triangular with a unit diagonal and D is a diagonal matrix. + * + * The decomposition uses pivoting to ensure stability, so that L will have + * zeros in the bottom right rank(A) - n submatrix. Avoiding the square root + * on D also stabilizes the computation. + * + * Remember that Cholesky decompositions are not rank-revealing. Also, do not use a Cholesky + * decomposition to determine whether a system of equations has a solution. + * + * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism. + * + * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT + */ +template class LDLT +{ + public: + typedef _MatrixType MatrixType; + enum { + RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime, + MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, + MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, + UpLo = _UpLo + }; + typedef typename MatrixType::Scalar Scalar; + typedef typename NumTraits::Real RealScalar; + typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3 + typedef typename MatrixType::StorageIndex StorageIndex; + typedef Matrix TmpMatrixType; + + typedef Transpositions TranspositionType; + typedef PermutationMatrix PermutationType; + + typedef internal::LDLT_Traits Traits; + + /** \brief Default Constructor. + * + * The default constructor is useful in cases in which the user intends to + * perform decompositions via LDLT::compute(const MatrixType&). + */ + LDLT() + : m_matrix(), + m_transpositions(), + m_sign(internal::ZeroSign), + m_isInitialized(false) + {} + + /** \brief Default Constructor with memory preallocation + * + * Like the default constructor but with preallocation of the internal data + * according to the specified problem \a size. + * \sa LDLT() + */ + explicit LDLT(Index size) + : m_matrix(size, size), + m_transpositions(size), + m_temporary(size), + m_sign(internal::ZeroSign), + m_isInitialized(false) + {} + + /** \brief Constructor with decomposition + * + * This calculates the decomposition for the input \a matrix. + * + * \sa LDLT(Index size) + */ + template + explicit LDLT(const EigenBase& matrix) + : m_matrix(matrix.rows(), matrix.cols()), + m_transpositions(matrix.rows()), + m_temporary(matrix.rows()), + m_sign(internal::ZeroSign), + m_isInitialized(false) + { + compute(matrix.derived()); + } + + /** \brief Constructs a LDLT factorization from a given matrix + * + * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref. + * + * \sa LDLT(const EigenBase&) + */ + template + explicit LDLT(EigenBase& matrix) + : m_matrix(matrix.derived()), + m_transpositions(matrix.rows()), + m_temporary(matrix.rows()), + m_sign(internal::ZeroSign), + m_isInitialized(false) + { + compute(matrix.derived()); + } + + /** Clear any existing decomposition + * \sa rankUpdate(w,sigma) + */ + void setZero() + { + m_isInitialized = false; + } + + /** \returns a view of the upper triangular matrix U */ + inline typename Traits::MatrixU matrixU() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return Traits::getU(m_matrix); + } + + /** \returns a view of the lower triangular matrix L */ + inline typename Traits::MatrixL matrixL() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return Traits::getL(m_matrix); + } + + /** \returns the permutation matrix P as a transposition sequence. + */ + inline const TranspositionType& transpositionsP() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return m_transpositions; + } + + /** \returns the coefficients of the diagonal matrix D */ + inline Diagonal vectorD() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return m_matrix.diagonal(); + } + + /** \returns true if the matrix is positive (semidefinite) */ + inline bool isPositive() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return m_sign == internal::PositiveSemiDef || m_sign == internal::ZeroSign; + } + + /** \returns true if the matrix is negative (semidefinite) */ + inline bool isNegative(void) const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return m_sign == internal::NegativeSemiDef || m_sign == internal::ZeroSign; + } + + /** \returns a solution x of \f$ A x = b \f$ using the current decomposition of A. + * + * This function also supports in-place solves using the syntax x = decompositionObject.solve(x) . + * + * \note_about_checking_solutions + * + * More precisely, this method solves \f$ A x = b \f$ using the decomposition \f$ A = P^T L D L^* P \f$ + * by solving the systems \f$ P^T y_1 = b \f$, \f$ L y_2 = y_1 \f$, \f$ D y_3 = y_2 \f$, + * \f$ L^* y_4 = y_3 \f$ and \f$ P x = y_4 \f$ in succession. If the matrix \f$ A \f$ is singular, then + * \f$ D \f$ will also be singular (all the other matrices are invertible). In that case, the + * least-square solution of \f$ D y_3 = y_2 \f$ is computed. This does not mean that this function + * computes the least-square solution of \f$ A x = b \f$ is \f$ A \f$ is singular. + * + * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt() + */ + template + inline const Solve + solve(const MatrixBase& b) const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_matrix.rows()==b.rows() + && "LDLT::solve(): invalid number of rows of the right hand side matrix b"); + return Solve(*this, b.derived()); + } + + template + bool solveInPlace(MatrixBase &bAndX) const; + + template + LDLT& compute(const EigenBase& matrix); + + /** \returns an estimate of the reciprocal condition number of the matrix of + * which \c *this is the LDLT decomposition. + */ + RealScalar rcond() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return internal::rcond_estimate_helper(m_l1_norm, *this); + } + + template + LDLT& rankUpdate(const MatrixBase& w, const RealScalar& alpha=1); + + /** \returns the internal LDLT decomposition matrix + * + * TODO: document the storage layout + */ + inline const MatrixType& matrixLDLT() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return m_matrix; + } + + MatrixType reconstructedMatrix() const; + + /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint. + * + * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as: + * \code x = decomposition.adjoint().solve(b) \endcode + */ + const LDLT& adjoint() const { return *this; }; + + inline Index rows() const { return m_matrix.rows(); } + inline Index cols() const { return m_matrix.cols(); } + + /** \brief Reports whether previous computation was successful. + * + * \returns \c Success if computation was succesful, + * \c NumericalIssue if the factorization failed because of a zero pivot. + */ + ComputationInfo info() const + { + eigen_assert(m_isInitialized && "LDLT is not initialized."); + return m_info; + } + + #ifndef EIGEN_PARSED_BY_DOXYGEN + template + EIGEN_DEVICE_FUNC + void _solve_impl(const RhsType &rhs, DstType &dst) const; + #endif + + protected: + + static void check_template_parameters() + { + EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar); + } + + /** \internal + * Used to compute and store the Cholesky decomposition A = L D L^* = U^* D U. + * The strict upper part is used during the decomposition, the strict lower + * part correspond to the coefficients of L (its diagonal is equal to 1 and + * is not stored), and the diagonal entries correspond to D. + */ + MatrixType m_matrix; + RealScalar m_l1_norm; + TranspositionType m_transpositions; + TmpMatrixType m_temporary; + internal::SignMatrix m_sign; + bool m_isInitialized; + ComputationInfo m_info; +}; + +namespace internal { + +template struct ldlt_inplace; + +template<> struct ldlt_inplace +{ + template + static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign) + { + using std::abs; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef typename TranspositionType::StorageIndex IndexType; + eigen_assert(mat.rows()==mat.cols()); + const Index size = mat.rows(); + bool found_zero_pivot = false; + bool ret = true; + + if (size <= 1) + { + transpositions.setIdentity(); + if (numext::real(mat.coeff(0,0)) > static_cast(0) ) sign = PositiveSemiDef; + else if (numext::real(mat.coeff(0,0)) < static_cast(0)) sign = NegativeSemiDef; + else sign = ZeroSign; + return true; + } + + for (Index k = 0; k < size; ++k) + { + // Find largest diagonal element + Index index_of_biggest_in_corner; + mat.diagonal().tail(size-k).cwiseAbs().maxCoeff(&index_of_biggest_in_corner); + index_of_biggest_in_corner += k; + + transpositions.coeffRef(k) = IndexType(index_of_biggest_in_corner); + if(k != index_of_biggest_in_corner) + { + // apply the transposition while taking care to consider only + // the lower triangular part + Index s = size-index_of_biggest_in_corner-1; // trailing size after the biggest element + mat.row(k).head(k).swap(mat.row(index_of_biggest_in_corner).head(k)); + mat.col(k).tail(s).swap(mat.col(index_of_biggest_in_corner).tail(s)); + std::swap(mat.coeffRef(k,k),mat.coeffRef(index_of_biggest_in_corner,index_of_biggest_in_corner)); + for(Index i=k+1;i::IsComplex) + mat.coeffRef(index_of_biggest_in_corner,k) = numext::conj(mat.coeff(index_of_biggest_in_corner,k)); + } + + // partition the matrix: + // A00 | - | - + // lu = A10 | A11 | - + // A20 | A21 | A22 + Index rs = size - k - 1; + Block A21(mat,k+1,k,rs,1); + Block A10(mat,k,0,1,k); + Block A20(mat,k+1,0,rs,k); + + if(k>0) + { + temp.head(k) = mat.diagonal().real().head(k).asDiagonal() * A10.adjoint(); + mat.coeffRef(k,k) -= (A10 * temp.head(k)).value(); + if(rs>0) + A21.noalias() -= A20 * temp.head(k); + } + + // In some previous versions of Eigen (e.g., 3.2.1), the scaling was omitted if the pivot + // was smaller than the cutoff value. However, since LDLT is not rank-revealing + // we should only make sure that we do not introduce INF or NaN values. + // Remark that LAPACK also uses 0 as the cutoff value. + RealScalar realAkk = numext::real(mat.coeffRef(k,k)); + bool pivot_is_valid = (abs(realAkk) > RealScalar(0)); + + if(k==0 && !pivot_is_valid) + { + // The entire diagonal is zero, there is nothing more to do + // except filling the transpositions, and checking whether the matrix is zero. + sign = ZeroSign; + for(Index j = 0; j0) && pivot_is_valid) + A21 /= realAkk; + else if(rs>0) + ret = ret && (A21.array()==Scalar(0)).all(); + + if(found_zero_pivot && pivot_is_valid) ret = false; // factorization failed + else if(!pivot_is_valid) found_zero_pivot = true; + + if (sign == PositiveSemiDef) { + if (realAkk < static_cast(0)) sign = Indefinite; + } else if (sign == NegativeSemiDef) { + if (realAkk > static_cast(0)) sign = Indefinite; + } else if (sign == ZeroSign) { + if (realAkk > static_cast(0)) sign = PositiveSemiDef; + else if (realAkk < static_cast(0)) sign = NegativeSemiDef; + } + } + + return ret; + } + + // Reference for the algorithm: Davis and Hager, "Multiple Rank + // Modifications of a Sparse Cholesky Factorization" (Algorithm 1) + // Trivial rearrangements of their computations (Timothy E. Holy) + // allow their algorithm to work for rank-1 updates even if the + // original matrix is not of full rank. + // Here only rank-1 updates are implemented, to reduce the + // requirement for intermediate storage and improve accuracy + template + static bool updateInPlace(MatrixType& mat, MatrixBase& w, const typename MatrixType::RealScalar& sigma=1) + { + using numext::isfinite; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + + const Index size = mat.rows(); + eigen_assert(mat.cols() == size && w.size()==size); + + RealScalar alpha = 1; + + // Apply the update + for (Index j = 0; j < size; j++) + { + // Check for termination due to an original decomposition of low-rank + if (!(isfinite)(alpha)) + break; + + // Update the diagonal terms + RealScalar dj = numext::real(mat.coeff(j,j)); + Scalar wj = w.coeff(j); + RealScalar swj2 = sigma*numext::abs2(wj); + RealScalar gamma = dj*alpha + swj2; + + mat.coeffRef(j,j) += swj2/alpha; + alpha += swj2/dj; + + + // Update the terms of L + Index rs = size-j-1; + w.tail(rs) -= wj * mat.col(j).tail(rs); + if(gamma != 0) + mat.col(j).tail(rs) += (sigma*numext::conj(wj)/gamma)*w.tail(rs); + } + return true; + } + + template + static bool update(MatrixType& mat, const TranspositionType& transpositions, Workspace& tmp, const WType& w, const typename MatrixType::RealScalar& sigma=1) + { + // Apply the permutation to the input w + tmp = transpositions * w; + + return ldlt_inplace::updateInPlace(mat,tmp,sigma); + } +}; + +template<> struct ldlt_inplace +{ + template + static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign) + { + Transpose matt(mat); + return ldlt_inplace::unblocked(matt, transpositions, temp, sign); + } + + template + static EIGEN_STRONG_INLINE bool update(MatrixType& mat, TranspositionType& transpositions, Workspace& tmp, WType& w, const typename MatrixType::RealScalar& sigma=1) + { + Transpose matt(mat); + return ldlt_inplace::update(matt, transpositions, tmp, w.conjugate(), sigma); + } +}; + +template struct LDLT_Traits +{ + typedef const TriangularView MatrixL; + typedef const TriangularView MatrixU; + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); } +}; + +template struct LDLT_Traits +{ + typedef const TriangularView MatrixL; + typedef const TriangularView MatrixU; + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); } +}; + +} // end namespace internal + +/** Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of \a matrix + */ +template +template +LDLT& LDLT::compute(const EigenBase& a) +{ + check_template_parameters(); + + eigen_assert(a.rows()==a.cols()); + const Index size = a.rows(); + + m_matrix = a.derived(); + + // Compute matrix L1 norm = max abs column sum. + m_l1_norm = RealScalar(0); + // TODO move this code to SelfAdjointView + for (Index col = 0; col < size; ++col) { + RealScalar abs_col_sum; + if (_UpLo == Lower) + abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>(); + else + abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>(); + if (abs_col_sum > m_l1_norm) + m_l1_norm = abs_col_sum; + } + + m_transpositions.resize(size); + m_isInitialized = false; + m_temporary.resize(size); + m_sign = internal::ZeroSign; + + m_info = internal::ldlt_inplace::unblocked(m_matrix, m_transpositions, m_temporary, m_sign) ? Success : NumericalIssue; + + m_isInitialized = true; + return *this; +} + +/** Update the LDLT decomposition: given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T. + * \param w a vector to be incorporated into the decomposition. + * \param sigma a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1. + * \sa setZero() + */ +template +template +LDLT& LDLT::rankUpdate(const MatrixBase& w, const typename LDLT::RealScalar& sigma) +{ + typedef typename TranspositionType::StorageIndex IndexType; + const Index size = w.rows(); + if (m_isInitialized) + { + eigen_assert(m_matrix.rows()==size); + } + else + { + m_matrix.resize(size,size); + m_matrix.setZero(); + m_transpositions.resize(size); + for (Index i = 0; i < size; i++) + m_transpositions.coeffRef(i) = IndexType(i); + m_temporary.resize(size); + m_sign = sigma>=0 ? internal::PositiveSemiDef : internal::NegativeSemiDef; + m_isInitialized = true; + } + + internal::ldlt_inplace::update(m_matrix, m_transpositions, m_temporary, w, sigma); + + return *this; +} + +#ifndef EIGEN_PARSED_BY_DOXYGEN +template +template +void LDLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const +{ + eigen_assert(rhs.rows() == rows()); + // dst = P b + dst = m_transpositions * rhs; + + // dst = L^-1 (P b) + matrixL().solveInPlace(dst); + + // dst = D^-1 (L^-1 P b) + // more precisely, use pseudo-inverse of D (see bug 241) + using std::abs; + const typename Diagonal::RealReturnType vecD(vectorD()); + // In some previous versions, tolerance was set to the max of 1/highest (or rather numeric_limits::min()) + // and the maximal diagonal entry * epsilon as motivated by LAPACK's xGELSS: + // RealScalar tolerance = numext::maxi(vecD.array().abs().maxCoeff() * NumTraits::epsilon(),RealScalar(1) / NumTraits::highest()); + // However, LDLT is not rank revealing, and so adjusting the tolerance wrt to the highest + // diagonal element is not well justified and leads to numerical issues in some cases. + // Moreover, Lapack's xSYTRS routines use 0 for the tolerance. + // Using numeric_limits::min() gives us more robustness to denormals. + RealScalar tolerance = (std::numeric_limits::min)(); + + for (Index i = 0; i < vecD.size(); ++i) + { + if(abs(vecD(i)) > tolerance) + dst.row(i) /= vecD(i); + else + dst.row(i).setZero(); + } + + // dst = L^-T (D^-1 L^-1 P b) + matrixU().solveInPlace(dst); + + // dst = P^-1 (L^-T D^-1 L^-1 P b) = A^-1 b + dst = m_transpositions.transpose() * dst; +} +#endif + +/** \internal use x = ldlt_object.solve(x); + * + * This is the \em in-place version of solve(). + * + * \param bAndX represents both the right-hand side matrix b and result x. + * + * \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD. + * + * This version avoids a copy when the right hand side matrix b is not + * needed anymore. + * + * \sa LDLT::solve(), MatrixBase::ldlt() + */ +template +template +bool LDLT::solveInPlace(MatrixBase &bAndX) const +{ + eigen_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_matrix.rows() == bAndX.rows()); + + bAndX = this->solve(bAndX); + + return true; +} + +/** \returns the matrix represented by the decomposition, + * i.e., it returns the product: P^T L D L^* P. + * This function is provided for debug purpose. */ +template +MatrixType LDLT::reconstructedMatrix() const +{ + eigen_assert(m_isInitialized && "LDLT is not initialized."); + const Index size = m_matrix.rows(); + MatrixType res(size,size); + + // P + res.setIdentity(); + res = transpositionsP() * res; + // L^* P + res = matrixU() * res; + // D(L^*P) + res = vectorD().real().asDiagonal() * res; + // L(DL^*P) + res = matrixL() * res; + // P^T (LDL^*P) + res = transpositionsP().transpose() * res; + + return res; +} + +/** \cholesky_module + * \returns the Cholesky decomposition with full pivoting without square root of \c *this + * \sa MatrixBase::ldlt() + */ +template +inline const LDLT::PlainObject, UpLo> +SelfAdjointView::ldlt() const +{ + return LDLT(m_matrix); +} + +/** \cholesky_module + * \returns the Cholesky decomposition with full pivoting without square root of \c *this + * \sa SelfAdjointView::ldlt() + */ +template +inline const LDLT::PlainObject> +MatrixBase::ldlt() const +{ + return LDLT(derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_LDLT_H diff --git a/3rdparty/eigen3/Eigen/src/Cholesky/LLT.h b/3rdparty/eigen3/Eigen/src/Cholesky/LLT.h new file mode 100644 index 0000000..e1624d2 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Cholesky/LLT.h @@ -0,0 +1,542 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_LLT_H +#define EIGEN_LLT_H + +namespace Eigen { + +namespace internal{ +template struct LLT_Traits; +} + +/** \ingroup Cholesky_Module + * + * \class LLT + * + * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features + * + * \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition + * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper. + * The other triangular part won't be read. + * + * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite + * matrix A such that A = LL^* = U^*U, where L is lower triangular. + * + * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like D^*D x = b, + * for that purpose, we recommend the Cholesky decomposition without square root which is more stable + * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other + * situations like generalised eigen problems with hermitian matrices. + * + * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices, + * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations + * has a solution. + * + * Example: \include LLT_example.cpp + * Output: \verbinclude LLT_example.out + * + * \b Performance: for best performance, it is recommended to use a column-major storage format + * with the Lower triangular part (the default), or, equivalently, a row-major storage format + * with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization + * step, and rank-updates can be up to 3 times slower. + * + * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism. + * + * Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered. + * Therefore, the strict lower part does not have to store correct values. + * + * \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT + */ +template class LLT +{ + public: + typedef _MatrixType MatrixType; + enum { + RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime, + MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime + }; + typedef typename MatrixType::Scalar Scalar; + typedef typename NumTraits::Real RealScalar; + typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3 + typedef typename MatrixType::StorageIndex StorageIndex; + + enum { + PacketSize = internal::packet_traits::size, + AlignmentMask = int(PacketSize)-1, + UpLo = _UpLo + }; + + typedef internal::LLT_Traits Traits; + + /** + * \brief Default Constructor. + * + * The default constructor is useful in cases in which the user intends to + * perform decompositions via LLT::compute(const MatrixType&). + */ + LLT() : m_matrix(), m_isInitialized(false) {} + + /** \brief Default Constructor with memory preallocation + * + * Like the default constructor but with preallocation of the internal data + * according to the specified problem \a size. + * \sa LLT() + */ + explicit LLT(Index size) : m_matrix(size, size), + m_isInitialized(false) {} + + template + explicit LLT(const EigenBase& matrix) + : m_matrix(matrix.rows(), matrix.cols()), + m_isInitialized(false) + { + compute(matrix.derived()); + } + + /** \brief Constructs a LDLT factorization from a given matrix + * + * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when + * \c MatrixType is a Eigen::Ref. + * + * \sa LLT(const EigenBase&) + */ + template + explicit LLT(EigenBase& matrix) + : m_matrix(matrix.derived()), + m_isInitialized(false) + { + compute(matrix.derived()); + } + + /** \returns a view of the upper triangular matrix U */ + inline typename Traits::MatrixU matrixU() const + { + eigen_assert(m_isInitialized && "LLT is not initialized."); + return Traits::getU(m_matrix); + } + + /** \returns a view of the lower triangular matrix L */ + inline typename Traits::MatrixL matrixL() const + { + eigen_assert(m_isInitialized && "LLT is not initialized."); + return Traits::getL(m_matrix); + } + + /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A. + * + * Since this LLT class assumes anyway that the matrix A is invertible, the solution + * theoretically exists and is unique regardless of b. + * + * Example: \include LLT_solve.cpp + * Output: \verbinclude LLT_solve.out + * + * \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt() + */ + template + inline const Solve + solve(const MatrixBase& b) const + { + eigen_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_matrix.rows()==b.rows() + && "LLT::solve(): invalid number of rows of the right hand side matrix b"); + return Solve(*this, b.derived()); + } + + template + void solveInPlace(const MatrixBase &bAndX) const; + + template + LLT& compute(const EigenBase& matrix); + + /** \returns an estimate of the reciprocal condition number of the matrix of + * which \c *this is the Cholesky decomposition. + */ + RealScalar rcond() const + { + eigen_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative"); + return internal::rcond_estimate_helper(m_l1_norm, *this); + } + + /** \returns the LLT decomposition matrix + * + * TODO: document the storage layout + */ + inline const MatrixType& matrixLLT() const + { + eigen_assert(m_isInitialized && "LLT is not initialized."); + return m_matrix; + } + + MatrixType reconstructedMatrix() const; + + + /** \brief Reports whether previous computation was successful. + * + * \returns \c Success if computation was succesful, + * \c NumericalIssue if the matrix.appears not to be positive definite. + */ + ComputationInfo info() const + { + eigen_assert(m_isInitialized && "LLT is not initialized."); + return m_info; + } + + /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint. + * + * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as: + * \code x = decomposition.adjoint().solve(b) \endcode + */ + const LLT& adjoint() const { return *this; }; + + inline Index rows() const { return m_matrix.rows(); } + inline Index cols() const { return m_matrix.cols(); } + + template + LLT rankUpdate(const VectorType& vec, const RealScalar& sigma = 1); + + #ifndef EIGEN_PARSED_BY_DOXYGEN + template + EIGEN_DEVICE_FUNC + void _solve_impl(const RhsType &rhs, DstType &dst) const; + #endif + + protected: + + static void check_template_parameters() + { + EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar); + } + + /** \internal + * Used to compute and store L + * The strict upper part is not used and even not initialized. + */ + MatrixType m_matrix; + RealScalar m_l1_norm; + bool m_isInitialized; + ComputationInfo m_info; +}; + +namespace internal { + +template struct llt_inplace; + +template +static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) +{ + using std::sqrt; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef typename MatrixType::ColXpr ColXpr; + typedef typename internal::remove_all::type ColXprCleaned; + typedef typename ColXprCleaned::SegmentReturnType ColXprSegment; + typedef Matrix TempVectorType; + typedef typename TempVectorType::SegmentReturnType TempVecSegment; + + Index n = mat.cols(); + eigen_assert(mat.rows()==n && vec.size()==n); + + TempVectorType temp; + + if(sigma>0) + { + // This version is based on Givens rotations. + // It is faster than the other one below, but only works for updates, + // i.e., for sigma > 0 + temp = sqrt(sigma) * vec; + + for(Index i=0; i g; + g.makeGivens(mat(i,i), -temp(i), &mat(i,i)); + + Index rs = n-i-1; + if(rs>0) + { + ColXprSegment x(mat.col(i).tail(rs)); + TempVecSegment y(temp.tail(rs)); + apply_rotation_in_the_plane(x, y, g); + } + } + } + else + { + temp = vec; + RealScalar beta = 1; + for(Index j=0; j struct llt_inplace +{ + typedef typename NumTraits::Real RealScalar; + template + static Index unblocked(MatrixType& mat) + { + using std::sqrt; + + eigen_assert(mat.rows()==mat.cols()); + const Index size = mat.rows(); + for(Index k = 0; k < size; ++k) + { + Index rs = size-k-1; // remaining size + + Block A21(mat,k+1,k,rs,1); + Block A10(mat,k,0,1,k); + Block A20(mat,k+1,0,rs,k); + + RealScalar x = numext::real(mat.coeff(k,k)); + if (k>0) x -= A10.squaredNorm(); + if (x<=RealScalar(0)) + return k; + mat.coeffRef(k,k) = x = sqrt(x); + if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint(); + if (rs>0) A21 /= x; + } + return -1; + } + + template + static Index blocked(MatrixType& m) + { + eigen_assert(m.rows()==m.cols()); + Index size = m.rows(); + if(size<32) + return unblocked(m); + + Index blockSize = size/8; + blockSize = (blockSize/16)*16; + blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128)); + + for (Index k=0; k A11(m,k, k, bs,bs); + Block A21(m,k+bs,k, rs,bs); + Block A22(m,k+bs,k+bs,rs,rs); + + Index ret; + if((ret=unblocked(A11))>=0) return k+ret; + if(rs>0) A11.adjoint().template triangularView().template solveInPlace(A21); + if(rs>0) A22.template selfadjointView().rankUpdate(A21,typename NumTraits::Literal(-1)); // bottleneck + } + return -1; + } + + template + static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma) + { + return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); + } +}; + +template struct llt_inplace +{ + typedef typename NumTraits::Real RealScalar; + + template + static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat) + { + Transpose matt(mat); + return llt_inplace::unblocked(matt); + } + template + static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat) + { + Transpose matt(mat); + return llt_inplace::blocked(matt); + } + template + static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma) + { + Transpose matt(mat); + return llt_inplace::rankUpdate(matt, vec.conjugate(), sigma); + } +}; + +template struct LLT_Traits +{ + typedef const TriangularView MatrixL; + typedef const TriangularView MatrixU; + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); } + static bool inplace_decomposition(MatrixType& m) + { return llt_inplace::blocked(m)==-1; } +}; + +template struct LLT_Traits +{ + typedef const TriangularView MatrixL; + typedef const TriangularView MatrixU; + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); } + static bool inplace_decomposition(MatrixType& m) + { return llt_inplace::blocked(m)==-1; } +}; + +} // end namespace internal + +/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix + * + * \returns a reference to *this + * + * Example: \include TutorialLinAlgComputeTwice.cpp + * Output: \verbinclude TutorialLinAlgComputeTwice.out + */ +template +template +LLT& LLT::compute(const EigenBase& a) +{ + check_template_parameters(); + + eigen_assert(a.rows()==a.cols()); + const Index size = a.rows(); + m_matrix.resize(size, size); + if (!internal::is_same_dense(m_matrix, a.derived())) + m_matrix = a.derived(); + + // Compute matrix L1 norm = max abs column sum. + m_l1_norm = RealScalar(0); + // TODO move this code to SelfAdjointView + for (Index col = 0; col < size; ++col) { + RealScalar abs_col_sum; + if (_UpLo == Lower) + abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>(); + else + abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>(); + if (abs_col_sum > m_l1_norm) + m_l1_norm = abs_col_sum; + } + + m_isInitialized = true; + bool ok = Traits::inplace_decomposition(m_matrix); + m_info = ok ? Success : NumericalIssue; + + return *this; +} + +/** Performs a rank one update (or dowdate) of the current decomposition. + * If A = LL^* before the rank one update, + * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector + * of same dimension. + */ +template +template +LLT<_MatrixType,_UpLo> LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType); + eigen_assert(v.size()==m_matrix.cols()); + eigen_assert(m_isInitialized); + if(internal::llt_inplace::rankUpdate(m_matrix,v,sigma)>=0) + m_info = NumericalIssue; + else + m_info = Success; + + return *this; +} + +#ifndef EIGEN_PARSED_BY_DOXYGEN +template +template +void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const +{ + dst = rhs; + solveInPlace(dst); +} +#endif + +/** \internal use x = llt_object.solve(x); + * + * This is the \em in-place version of solve(). + * + * \param bAndX represents both the right-hand side matrix b and result x. + * + * This version avoids a copy when the right hand side matrix b is not needed anymore. + * + * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here. + * This function will const_cast it, so constness isn't honored here. + * + * \sa LLT::solve(), MatrixBase::llt() + */ +template +template +void LLT::solveInPlace(const MatrixBase &bAndX) const +{ + eigen_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_matrix.rows()==bAndX.rows()); + matrixL().solveInPlace(bAndX); + matrixU().solveInPlace(bAndX); +} + +/** \returns the matrix represented by the decomposition, + * i.e., it returns the product: L L^*. + * This function is provided for debug purpose. */ +template +MatrixType LLT::reconstructedMatrix() const +{ + eigen_assert(m_isInitialized && "LLT is not initialized."); + return matrixL() * matrixL().adjoint().toDenseMatrix(); +} + +/** \cholesky_module + * \returns the LLT decomposition of \c *this + * \sa SelfAdjointView::llt() + */ +template +inline const LLT::PlainObject> +MatrixBase::llt() const +{ + return LLT(derived()); +} + +/** \cholesky_module + * \returns the LLT decomposition of \c *this + * \sa SelfAdjointView::llt() + */ +template +inline const LLT::PlainObject, UpLo> +SelfAdjointView::llt() const +{ + return LLT(m_matrix); +} + +} // end namespace Eigen + +#endif // EIGEN_LLT_H diff --git a/3rdparty/eigen3/Eigen/src/Cholesky/LLT_LAPACKE.h b/3rdparty/eigen3/Eigen/src/Cholesky/LLT_LAPACKE.h new file mode 100644 index 0000000..bc6489e --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Cholesky/LLT_LAPACKE.h @@ -0,0 +1,99 @@ +/* + Copyright (c) 2011, Intel Corporation. All rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + ******************************************************************************** + * Content : Eigen bindings to LAPACKe + * LLt decomposition based on LAPACKE_?potrf function. + ******************************************************************************** +*/ + +#ifndef EIGEN_LLT_LAPACKE_H +#define EIGEN_LLT_LAPACKE_H + +namespace Eigen { + +namespace internal { + +template struct lapacke_llt; + +#define EIGEN_LAPACKE_LLT(EIGTYPE, BLASTYPE, LAPACKE_PREFIX) \ +template<> struct lapacke_llt \ +{ \ + template \ + static inline Index potrf(MatrixType& m, char uplo) \ + { \ + lapack_int matrix_order; \ + lapack_int size, lda, info, StorageOrder; \ + EIGTYPE* a; \ + eigen_assert(m.rows()==m.cols()); \ + /* Set up parameters for ?potrf */ \ + size = convert_index(m.rows()); \ + StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; \ + matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ + a = &(m.coeffRef(0,0)); \ + lda = convert_index(m.outerStride()); \ +\ + info = LAPACKE_##LAPACKE_PREFIX##potrf( matrix_order, uplo, size, (BLASTYPE*)a, lda ); \ + info = (info==0) ? -1 : info>0 ? info-1 : size; \ + return info; \ + } \ +}; \ +template<> struct llt_inplace \ +{ \ + template \ + static Index blocked(MatrixType& m) \ + { \ + return lapacke_llt::potrf(m, 'L'); \ + } \ + template \ + static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \ + { return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); } \ +}; \ +template<> struct llt_inplace \ +{ \ + template \ + static Index blocked(MatrixType& m) \ + { \ + return lapacke_llt::potrf(m, 'U'); \ + } \ + template \ + static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \ + { \ + Transpose matt(mat); \ + return llt_inplace::rankUpdate(matt, vec.conjugate(), sigma); \ + } \ +}; + +EIGEN_LAPACKE_LLT(double, double, d) +EIGEN_LAPACKE_LLT(float, float, s) +EIGEN_LAPACKE_LLT(dcomplex, lapack_complex_double, z) +EIGEN_LAPACKE_LLT(scomplex, lapack_complex_float, c) + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_LLT_LAPACKE_H diff --git a/3rdparty/eigen3/Eigen/src/CholmodSupport/CholmodSupport.h b/3rdparty/eigen3/Eigen/src/CholmodSupport/CholmodSupport.h new file mode 100644 index 0000000..5719720 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/CholmodSupport/CholmodSupport.h @@ -0,0 +1,639 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CHOLMODSUPPORT_H +#define EIGEN_CHOLMODSUPPORT_H + +namespace Eigen { + +namespace internal { + +template struct cholmod_configure_matrix; + +template<> struct cholmod_configure_matrix { + template + static void run(CholmodType& mat) { + mat.xtype = CHOLMOD_REAL; + mat.dtype = CHOLMOD_DOUBLE; + } +}; + +template<> struct cholmod_configure_matrix > { + template + static void run(CholmodType& mat) { + mat.xtype = CHOLMOD_COMPLEX; + mat.dtype = CHOLMOD_DOUBLE; + } +}; + +// Other scalar types are not yet suppotred by Cholmod +// template<> struct cholmod_configure_matrix { +// template +// static void run(CholmodType& mat) { +// mat.xtype = CHOLMOD_REAL; +// mat.dtype = CHOLMOD_SINGLE; +// } +// }; +// +// template<> struct cholmod_configure_matrix > { +// template +// static void run(CholmodType& mat) { +// mat.xtype = CHOLMOD_COMPLEX; +// mat.dtype = CHOLMOD_SINGLE; +// } +// }; + +} // namespace internal + +/** Wraps the Eigen sparse matrix \a mat into a Cholmod sparse matrix object. + * Note that the data are shared. + */ +template +cholmod_sparse viewAsCholmod(Ref > mat) +{ + cholmod_sparse res; + res.nzmax = mat.nonZeros(); + res.nrow = mat.rows(); + res.ncol = mat.cols(); + res.p = mat.outerIndexPtr(); + res.i = mat.innerIndexPtr(); + res.x = mat.valuePtr(); + res.z = 0; + res.sorted = 1; + if(mat.isCompressed()) + { + res.packed = 1; + res.nz = 0; + } + else + { + res.packed = 0; + res.nz = mat.innerNonZeroPtr(); + } + + res.dtype = 0; + res.stype = -1; + + if (internal::is_same<_StorageIndex,int>::value) + { + res.itype = CHOLMOD_INT; + } + else if (internal::is_same<_StorageIndex,long>::value) + { + res.itype = CHOLMOD_LONG; + } + else + { + eigen_assert(false && "Index type not supported yet"); + } + + // setup res.xtype + internal::cholmod_configure_matrix<_Scalar>::run(res); + + res.stype = 0; + + return res; +} + +template +const cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>& mat) +{ + cholmod_sparse res = viewAsCholmod(Ref >(mat.const_cast_derived())); + return res; +} + +template +const cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>& mat) +{ + cholmod_sparse res = viewAsCholmod(Ref >(mat.const_cast_derived())); + return res; +} + +/** Returns a view of the Eigen sparse matrix \a mat as Cholmod sparse matrix. + * The data are not copied but shared. */ +template +cholmod_sparse viewAsCholmod(const SparseSelfAdjointView, UpLo>& mat) +{ + cholmod_sparse res = viewAsCholmod(Ref >(mat.matrix().const_cast_derived())); + + if(UpLo==Upper) res.stype = 1; + if(UpLo==Lower) res.stype = -1; + + return res; +} + +/** Returns a view of the Eigen \b dense matrix \a mat as Cholmod dense matrix. + * The data are not copied but shared. */ +template +cholmod_dense viewAsCholmod(MatrixBase& mat) +{ + EIGEN_STATIC_ASSERT((internal::traits::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES); + typedef typename Derived::Scalar Scalar; + + cholmod_dense res; + res.nrow = mat.rows(); + res.ncol = mat.cols(); + res.nzmax = res.nrow * res.ncol; + res.d = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride(); + res.x = (void*)(mat.derived().data()); + res.z = 0; + + internal::cholmod_configure_matrix::run(res); + + return res; +} + +/** Returns a view of the Cholmod sparse matrix \a cm as an Eigen sparse matrix. + * The data are not copied but shared. */ +template +MappedSparseMatrix viewAsEigen(cholmod_sparse& cm) +{ + return MappedSparseMatrix + (cm.nrow, cm.ncol, static_cast(cm.p)[cm.ncol], + static_cast(cm.p), static_cast(cm.i),static_cast(cm.x) ); +} + +enum CholmodMode { + CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt +}; + + +/** \ingroup CholmodSupport_Module + * \class CholmodBase + * \brief The base class for the direct Cholesky factorization of Cholmod + * \sa class CholmodSupernodalLLT, class CholmodSimplicialLDLT, class CholmodSimplicialLLT + */ +template +class CholmodBase : public SparseSolverBase +{ + protected: + typedef SparseSolverBase Base; + using Base::derived; + using Base::m_isInitialized; + public: + typedef _MatrixType MatrixType; + enum { UpLo = _UpLo }; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef MatrixType CholMatrixType; + typedef typename MatrixType::StorageIndex StorageIndex; + enum { + ColsAtCompileTime = MatrixType::ColsAtCompileTime, + MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime + }; + + public: + + CholmodBase() + : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false) + { + EIGEN_STATIC_ASSERT((internal::is_same::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY); + m_shiftOffset[0] = m_shiftOffset[1] = 0.0; + cholmod_start(&m_cholmod); + } + + explicit CholmodBase(const MatrixType& matrix) + : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false) + { + EIGEN_STATIC_ASSERT((internal::is_same::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY); + m_shiftOffset[0] = m_shiftOffset[1] = 0.0; + cholmod_start(&m_cholmod); + compute(matrix); + } + + ~CholmodBase() + { + if(m_cholmodFactor) + cholmod_free_factor(&m_cholmodFactor, &m_cholmod); + cholmod_finish(&m_cholmod); + } + + inline StorageIndex cols() const { return internal::convert_index(m_cholmodFactor->n); } + inline StorageIndex rows() const { return internal::convert_index(m_cholmodFactor->n); } + + /** \brief Reports whether previous computation was successful. + * + * \returns \c Success if computation was succesful, + * \c NumericalIssue if the matrix.appears to be negative. + */ + ComputationInfo info() const + { + eigen_assert(m_isInitialized && "Decomposition is not initialized."); + return m_info; + } + + /** Computes the sparse Cholesky decomposition of \a matrix */ + Derived& compute(const MatrixType& matrix) + { + analyzePattern(matrix); + factorize(matrix); + return derived(); + } + + /** Performs a symbolic decomposition on the sparsity pattern of \a matrix. + * + * This function is particularly useful when solving for several problems having the same structure. + * + * \sa factorize() + */ + void analyzePattern(const MatrixType& matrix) + { + if(m_cholmodFactor) + { + cholmod_free_factor(&m_cholmodFactor, &m_cholmod); + m_cholmodFactor = 0; + } + cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView()); + m_cholmodFactor = cholmod_analyze(&A, &m_cholmod); + + this->m_isInitialized = true; + this->m_info = Success; + m_analysisIsOk = true; + m_factorizationIsOk = false; + } + + /** Performs a numeric decomposition of \a matrix + * + * The given matrix must have the same sparsity pattern as the matrix on which the symbolic decomposition has been performed. + * + * \sa analyzePattern() + */ + void factorize(const MatrixType& matrix) + { + eigen_assert(m_analysisIsOk && "You must first call analyzePattern()"); + cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView()); + cholmod_factorize_p(&A, m_shiftOffset, 0, 0, m_cholmodFactor, &m_cholmod); + + // If the factorization failed, minor is the column at which it did. On success minor == n. + this->m_info = (m_cholmodFactor->minor == m_cholmodFactor->n ? Success : NumericalIssue); + m_factorizationIsOk = true; + } + + /** Returns a reference to the Cholmod's configuration structure to get a full control over the performed operations. + * See the Cholmod user guide for details. */ + cholmod_common& cholmod() { return m_cholmod; } + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** \internal */ + template + void _solve_impl(const MatrixBase &b, MatrixBase &dest) const + { + eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()"); + const Index size = m_cholmodFactor->n; + EIGEN_UNUSED_VARIABLE(size); + eigen_assert(size==b.rows()); + + // Cholmod needs column-major stoarge without inner-stride, which corresponds to the default behavior of Ref. + Ref > b_ref(b.derived()); + + cholmod_dense b_cd = viewAsCholmod(b_ref); + cholmod_dense* x_cd = cholmod_solve(CHOLMOD_A, m_cholmodFactor, &b_cd, &m_cholmod); + if(!x_cd) + { + this->m_info = NumericalIssue; + return; + } + // TODO optimize this copy by swapping when possible (be careful with alignment, etc.) + dest = Matrix::Map(reinterpret_cast(x_cd->x),b.rows(),b.cols()); + cholmod_free_dense(&x_cd, &m_cholmod); + } + + /** \internal */ + template + void _solve_impl(const SparseMatrixBase &b, SparseMatrixBase &dest) const + { + eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()"); + const Index size = m_cholmodFactor->n; + EIGEN_UNUSED_VARIABLE(size); + eigen_assert(size==b.rows()); + + // note: cs stands for Cholmod Sparse + Ref > b_ref(b.const_cast_derived()); + cholmod_sparse b_cs = viewAsCholmod(b_ref); + cholmod_sparse* x_cs = cholmod_spsolve(CHOLMOD_A, m_cholmodFactor, &b_cs, &m_cholmod); + if(!x_cs) + { + this->m_info = NumericalIssue; + return; + } + // TODO optimize this copy by swapping when possible (be careful with alignment, etc.) + dest.derived() = viewAsEigen(*x_cs); + cholmod_free_sparse(&x_cs, &m_cholmod); + } + #endif // EIGEN_PARSED_BY_DOXYGEN + + + /** Sets the shift parameter that will be used to adjust the diagonal coefficients during the numerical factorization. + * + * During the numerical factorization, an offset term is added to the diagonal coefficients:\n + * \c d_ii = \a offset + \c d_ii + * + * The default is \a offset=0. + * + * \returns a reference to \c *this. + */ + Derived& setShift(const RealScalar& offset) + { + m_shiftOffset[0] = double(offset); + return derived(); + } + + /** \returns the determinant of the underlying matrix from the current factorization */ + Scalar determinant() const + { + using std::exp; + return exp(logDeterminant()); + } + + /** \returns the log determinant of the underlying matrix from the current factorization */ + Scalar logDeterminant() const + { + using std::log; + using numext::real; + eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()"); + + RealScalar logDet = 0; + Scalar *x = static_cast(m_cholmodFactor->x); + if (m_cholmodFactor->is_super) + { + // Supernodal factorization stored as a packed list of dense column-major blocs, + // as described by the following structure: + + // super[k] == index of the first column of the j-th super node + StorageIndex *super = static_cast(m_cholmodFactor->super); + // pi[k] == offset to the description of row indices + StorageIndex *pi = static_cast(m_cholmodFactor->pi); + // px[k] == offset to the respective dense block + StorageIndex *px = static_cast(m_cholmodFactor->px); + + Index nb_super_nodes = m_cholmodFactor->nsuper; + for (Index k=0; k < nb_super_nodes; ++k) + { + StorageIndex ncols = super[k + 1] - super[k]; + StorageIndex nrows = pi[k + 1] - pi[k]; + + Map, 0, InnerStride<> > sk(x + px[k], ncols, InnerStride<>(nrows+1)); + logDet += sk.real().log().sum(); + } + } + else + { + // Simplicial factorization stored as standard CSC matrix. + StorageIndex *p = static_cast(m_cholmodFactor->p); + Index size = m_cholmodFactor->n; + for (Index k=0; kis_ll) + logDet *= 2.0; + return logDet; + }; + + template + void dumpMemory(Stream& /*s*/) + {} + + protected: + mutable cholmod_common m_cholmod; + cholmod_factor* m_cholmodFactor; + double m_shiftOffset[2]; + mutable ComputationInfo m_info; + int m_factorizationIsOk; + int m_analysisIsOk; +}; + +/** \ingroup CholmodSupport_Module + * \class CholmodSimplicialLLT + * \brief A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod + * + * This class allows to solve for A.X = B sparse linear problems via a simplicial LL^T Cholesky factorization + * using the Cholmod library. + * This simplicial variant is equivalent to Eigen's built-in SimplicialLLT class. Therefore, it has little practical interest. + * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices + * X and B can be either dense or sparse. + * + * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<> + * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower + * or Upper. Default is Lower. + * + * \implsparsesolverconcept + * + * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed. + * + * \warning Only double precision real and complex scalar types are supported by Cholmod. + * + * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLLT + */ +template +class CholmodSimplicialLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT<_MatrixType, _UpLo> > +{ + typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT> Base; + using Base::m_cholmod; + + public: + + typedef _MatrixType MatrixType; + + CholmodSimplicialLLT() : Base() { init(); } + + CholmodSimplicialLLT(const MatrixType& matrix) : Base() + { + init(); + this->compute(matrix); + } + + ~CholmodSimplicialLLT() {} + protected: + void init() + { + m_cholmod.final_asis = 0; + m_cholmod.supernodal = CHOLMOD_SIMPLICIAL; + m_cholmod.final_ll = 1; + } +}; + + +/** \ingroup CholmodSupport_Module + * \class CholmodSimplicialLDLT + * \brief A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod + * + * This class allows to solve for A.X = B sparse linear problems via a simplicial LDL^T Cholesky factorization + * using the Cholmod library. + * This simplicial variant is equivalent to Eigen's built-in SimplicialLDLT class. Therefore, it has little practical interest. + * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices + * X and B can be either dense or sparse. + * + * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<> + * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower + * or Upper. Default is Lower. + * + * \implsparsesolverconcept + * + * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed. + * + * \warning Only double precision real and complex scalar types are supported by Cholmod. + * + * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLDLT + */ +template +class CholmodSimplicialLDLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT<_MatrixType, _UpLo> > +{ + typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT> Base; + using Base::m_cholmod; + + public: + + typedef _MatrixType MatrixType; + + CholmodSimplicialLDLT() : Base() { init(); } + + CholmodSimplicialLDLT(const MatrixType& matrix) : Base() + { + init(); + this->compute(matrix); + } + + ~CholmodSimplicialLDLT() {} + protected: + void init() + { + m_cholmod.final_asis = 1; + m_cholmod.supernodal = CHOLMOD_SIMPLICIAL; + } +}; + +/** \ingroup CholmodSupport_Module + * \class CholmodSupernodalLLT + * \brief A supernodal Cholesky (LLT) factorization and solver based on Cholmod + * + * This class allows to solve for A.X = B sparse linear problems via a supernodal LL^T Cholesky factorization + * using the Cholmod library. + * This supernodal variant performs best on dense enough problems, e.g., 3D FEM, or very high order 2D FEM. + * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices + * X and B can be either dense or sparse. + * + * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<> + * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower + * or Upper. Default is Lower. + * + * \implsparsesolverconcept + * + * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed. + * + * \warning Only double precision real and complex scalar types are supported by Cholmod. + * + * \sa \ref TutorialSparseSolverConcept + */ +template +class CholmodSupernodalLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT<_MatrixType, _UpLo> > +{ + typedef CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT> Base; + using Base::m_cholmod; + + public: + + typedef _MatrixType MatrixType; + + CholmodSupernodalLLT() : Base() { init(); } + + CholmodSupernodalLLT(const MatrixType& matrix) : Base() + { + init(); + this->compute(matrix); + } + + ~CholmodSupernodalLLT() {} + protected: + void init() + { + m_cholmod.final_asis = 1; + m_cholmod.supernodal = CHOLMOD_SUPERNODAL; + } +}; + +/** \ingroup CholmodSupport_Module + * \class CholmodDecomposition + * \brief A general Cholesky factorization and solver based on Cholmod + * + * This class allows to solve for A.X = B sparse linear problems via a LL^T or LDL^T Cholesky factorization + * using the Cholmod library. The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices + * X and B can be either dense or sparse. + * + * This variant permits to change the underlying Cholesky method at runtime. + * On the other hand, it does not provide access to the result of the factorization. + * The default is to let Cholmod automatically choose between a simplicial and supernodal factorization. + * + * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<> + * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower + * or Upper. Default is Lower. + * + * \implsparsesolverconcept + * + * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed. + * + * \warning Only double precision real and complex scalar types are supported by Cholmod. + * + * \sa \ref TutorialSparseSolverConcept + */ +template +class CholmodDecomposition : public CholmodBase<_MatrixType, _UpLo, CholmodDecomposition<_MatrixType, _UpLo> > +{ + typedef CholmodBase<_MatrixType, _UpLo, CholmodDecomposition> Base; + using Base::m_cholmod; + + public: + + typedef _MatrixType MatrixType; + + CholmodDecomposition() : Base() { init(); } + + CholmodDecomposition(const MatrixType& matrix) : Base() + { + init(); + this->compute(matrix); + } + + ~CholmodDecomposition() {} + + void setMode(CholmodMode mode) + { + switch(mode) + { + case CholmodAuto: + m_cholmod.final_asis = 1; + m_cholmod.supernodal = CHOLMOD_AUTO; + break; + case CholmodSimplicialLLt: + m_cholmod.final_asis = 0; + m_cholmod.supernodal = CHOLMOD_SIMPLICIAL; + m_cholmod.final_ll = 1; + break; + case CholmodSupernodalLLt: + m_cholmod.final_asis = 1; + m_cholmod.supernodal = CHOLMOD_SUPERNODAL; + break; + case CholmodLDLt: + m_cholmod.final_asis = 1; + m_cholmod.supernodal = CHOLMOD_SIMPLICIAL; + break; + default: + break; + } + } + protected: + void init() + { + m_cholmod.final_asis = 1; + m_cholmod.supernodal = CHOLMOD_AUTO; + } +}; + +} // end namespace Eigen + +#endif // EIGEN_CHOLMODSUPPORT_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Array.h b/3rdparty/eigen3/Eigen/src/Core/Array.h new file mode 100644 index 0000000..e10020d --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Array.h @@ -0,0 +1,331 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ARRAY_H +#define EIGEN_ARRAY_H + +namespace Eigen { + +namespace internal { +template +struct traits > : traits > +{ + typedef ArrayXpr XprKind; + typedef ArrayBase > XprBase; +}; +} + +/** \class Array + * \ingroup Core_Module + * + * \brief General-purpose arrays with easy API for coefficient-wise operations + * + * The %Array class is very similar to the Matrix class. It provides + * general-purpose one- and two-dimensional arrays. The difference between the + * %Array and the %Matrix class is primarily in the API: the API for the + * %Array class provides easy access to coefficient-wise operations, while the + * API for the %Matrix class provides easy access to linear-algebra + * operations. + * + * See documentation of class Matrix for detailed information on the template parameters + * storage layout. + * + * This class can be extended with the help of the plugin mechanism described on the page + * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAY_PLUGIN. + * + * \sa \blank \ref TutorialArrayClass, \ref TopicClassHierarchy + */ +template +class Array + : public PlainObjectBase > +{ + public: + + typedef PlainObjectBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Array) + + enum { Options = _Options }; + typedef typename Base::PlainObject PlainObject; + + protected: + template + friend struct internal::conservative_resize_like_impl; + + using Base::m_storage; + + public: + + using Base::base; + using Base::coeff; + using Base::coeffRef; + + /** + * The usage of + * using Base::operator=; + * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped + * the usage of 'using'. This should be done only for operator=. + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array& operator=(const EigenBase &other) + { + return Base::operator=(other); + } + + /** Set all the entries to \a value. + * \sa DenseBase::setConstant(), DenseBase::fill() + */ + /* This overload is needed because the usage of + * using Base::operator=; + * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped + * the usage of 'using'. This should be done only for operator=. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array& operator=(const Scalar &value) + { + Base::setConstant(value); + return *this; + } + + /** Copies the value of the expression \a other into \c *this with automatic resizing. + * + * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized), + * it will be initialized. + * + * Note that copying a row-vector into a vector (and conversely) is allowed. + * The resizing, if any, is then done in the appropriate way so that row-vectors + * remain row-vectors and vectors remain vectors. + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array& operator=(const DenseBase& other) + { + return Base::_set(other); + } + + /** This is a special case of the templated operator=. Its purpose is to + * prevent a default operator= from hiding the templated operator=. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array& operator=(const Array& other) + { + return Base::_set(other); + } + + /** Default constructor. + * + * For fixed-size matrices, does nothing. + * + * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix + * is called a null matrix. This constructor is the unique way to create null matrices: resizing + * a matrix to 0 is not supported. + * + * \sa resize(Index,Index) + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array() : Base() + { + Base::_check_template_params(); + EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + } + +#ifndef EIGEN_PARSED_BY_DOXYGEN + // FIXME is it still needed ?? + /** \internal */ + EIGEN_DEVICE_FUNC + Array(internal::constructor_without_unaligned_array_assert) + : Base(internal::constructor_without_unaligned_array_assert()) + { + Base::_check_template_params(); + EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + } +#endif + +#if EIGEN_HAS_RVALUE_REFERENCES + EIGEN_DEVICE_FUNC + Array(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible::value) + : Base(std::move(other)) + { + Base::_check_template_params(); + if (RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic) + Base::_set_noalias(other); + } + EIGEN_DEVICE_FUNC + Array& operator=(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable::value) + { + other.swap(*this); + return *this; + } +#endif + + #ifndef EIGEN_PARSED_BY_DOXYGEN + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE explicit Array(const T& x) + { + Base::_check_template_params(); + Base::template _init1(x); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1) + { + Base::_check_template_params(); + this->template _init2(val0, val1); + } + #else + /** \brief Constructs a fixed-sized array initialized with coefficients starting at \a data */ + EIGEN_DEVICE_FUNC explicit Array(const Scalar *data); + /** Constructs a vector or row-vector with given dimension. \only_for_vectors + * + * Note that this is only useful for dynamic-size vectors. For fixed-size vectors, + * it is redundant to pass the dimension here, so it makes more sense to use the default + * constructor Array() instead. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE explicit Array(Index dim); + /** constructs an initialized 1x1 Array with the given coefficient */ + Array(const Scalar& value); + /** constructs an uninitialized array with \a rows rows and \a cols columns. + * + * This is useful for dynamic-size arrays. For fixed-size arrays, + * it is redundant to pass these parameters, so one should use the default constructor + * Array() instead. */ + Array(Index rows, Index cols); + /** constructs an initialized 2D vector with given coefficients */ + Array(const Scalar& val0, const Scalar& val1); + #endif + + /** constructs an initialized 3D vector with given coefficients */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2) + { + Base::_check_template_params(); + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 3) + m_storage.data()[0] = val0; + m_storage.data()[1] = val1; + m_storage.data()[2] = val2; + } + /** constructs an initialized 4D vector with given coefficients */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2, const Scalar& val3) + { + Base::_check_template_params(); + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 4) + m_storage.data()[0] = val0; + m_storage.data()[1] = val1; + m_storage.data()[2] = val2; + m_storage.data()[3] = val3; + } + + /** Copy constructor */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array(const Array& other) + : Base(other) + { } + + private: + struct PrivateType {}; + public: + + /** \sa MatrixBase::operator=(const EigenBase&) */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Array(const EigenBase &other, + typename internal::enable_if::value, + PrivateType>::type = PrivateType()) + : Base(other.derived()) + { } + + EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; } + EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); } + + #ifdef EIGEN_ARRAY_PLUGIN + #include EIGEN_ARRAY_PLUGIN + #endif + + private: + + template + friend struct internal::matrix_swap_impl; +}; + +/** \defgroup arraytypedefs Global array typedefs + * \ingroup Core_Module + * + * Eigen defines several typedef shortcuts for most common 1D and 2D array types. + * + * The general patterns are the following: + * + * \c ArrayRowsColsType where \c Rows and \c Cols can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size, + * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd + * for complex double. + * + * For example, \c Array33d is a fixed-size 3x3 array type of doubles, and \c ArrayXXf is a dynamic-size matrix of floats. + * + * There are also \c ArraySizeType which are self-explanatory. For example, \c Array4cf is + * a fixed-size 1D array of 4 complex floats. + * + * \sa class Array + */ + +#define EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \ +/** \ingroup arraytypedefs */ \ +typedef Array Array##SizeSuffix##SizeSuffix##TypeSuffix; \ +/** \ingroup arraytypedefs */ \ +typedef Array Array##SizeSuffix##TypeSuffix; + +#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \ +/** \ingroup arraytypedefs */ \ +typedef Array Array##Size##X##TypeSuffix; \ +/** \ingroup arraytypedefs */ \ +typedef Array Array##X##Size##TypeSuffix; + +#define EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \ +EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 2, 2) \ +EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 3, 3) \ +EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 4, 4) \ +EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \ +EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \ +EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \ +EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 4) + +EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(int, i) +EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(float, f) +EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(double, d) +EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex, cf) +EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex, cd) + +#undef EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES +#undef EIGEN_MAKE_ARRAY_TYPEDEFS + +#undef EIGEN_MAKE_ARRAY_TYPEDEFS_LARGE + +#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \ +using Eigen::Matrix##SizeSuffix##TypeSuffix; \ +using Eigen::Vector##SizeSuffix##TypeSuffix; \ +using Eigen::RowVector##SizeSuffix##TypeSuffix; + +#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(TypeSuffix) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \ + +#define EIGEN_USING_ARRAY_TYPEDEFS \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(i) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(f) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(d) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cf) \ +EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cd) + +} // end namespace Eigen + +#endif // EIGEN_ARRAY_H diff --git a/3rdparty/eigen3/Eigen/src/Core/ArrayBase.h b/3rdparty/eigen3/Eigen/src/Core/ArrayBase.h new file mode 100644 index 0000000..3dbc708 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/ArrayBase.h @@ -0,0 +1,226 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ARRAYBASE_H +#define EIGEN_ARRAYBASE_H + +namespace Eigen { + +template class MatrixWrapper; + +/** \class ArrayBase + * \ingroup Core_Module + * + * \brief Base class for all 1D and 2D array, and related expressions + * + * An array is similar to a dense vector or matrix. While matrices are mathematical + * objects with well defined linear algebra operators, an array is just a collection + * of scalar values arranged in a one or two dimensionnal fashion. As the main consequence, + * all operations applied to an array are performed coefficient wise. Furthermore, + * arrays support scalar math functions of the c++ standard library (e.g., std::sin(x)), and convenient + * constructors allowing to easily write generic code working for both scalar values + * and arrays. + * + * This class is the base that is inherited by all array expression types. + * + * \tparam Derived is the derived type, e.g., an array or an expression type. + * + * This class can be extended with the help of the plugin mechanism described on the page + * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAYBASE_PLUGIN. + * + * \sa class MatrixBase, \ref TopicClassHierarchy + */ +template class ArrayBase + : public DenseBase +{ + public: +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** The base class for a given storage type. */ + typedef ArrayBase StorageBaseType; + + typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl; + + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; + typedef typename NumTraits::Real RealScalar; + + typedef DenseBase Base; + using Base::RowsAtCompileTime; + using Base::ColsAtCompileTime; + using Base::SizeAtCompileTime; + using Base::MaxRowsAtCompileTime; + using Base::MaxColsAtCompileTime; + using Base::MaxSizeAtCompileTime; + using Base::IsVectorAtCompileTime; + using Base::Flags; + + using Base::derived; + using Base::const_cast_derived; + using Base::rows; + using Base::cols; + using Base::size; + using Base::coeff; + using Base::coeffRef; + using Base::lazyAssign; + using Base::operator=; + using Base::operator+=; + using Base::operator-=; + using Base::operator*=; + using Base::operator/=; + + typedef typename Base::CoeffReturnType CoeffReturnType; + +#endif // not EIGEN_PARSED_BY_DOXYGEN + +#ifndef EIGEN_PARSED_BY_DOXYGEN + typedef typename Base::PlainObject PlainObject; + + /** \internal Represents a matrix with all coefficients equal to one another*/ + typedef CwiseNullaryOp,PlainObject> ConstantReturnType; +#endif // not EIGEN_PARSED_BY_DOXYGEN + +#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase +#define EIGEN_DOC_UNARY_ADDONS(X,Y) +# include "../plugins/CommonCwiseUnaryOps.h" +# include "../plugins/MatrixCwiseUnaryOps.h" +# include "../plugins/ArrayCwiseUnaryOps.h" +# include "../plugins/CommonCwiseBinaryOps.h" +# include "../plugins/MatrixCwiseBinaryOps.h" +# include "../plugins/ArrayCwiseBinaryOps.h" +# ifdef EIGEN_ARRAYBASE_PLUGIN +# include EIGEN_ARRAYBASE_PLUGIN +# endif +#undef EIGEN_CURRENT_STORAGE_BASE_CLASS +#undef EIGEN_DOC_UNARY_ADDONS + + /** Special case of the template operator=, in order to prevent the compiler + * from generating a default operator= (issue hit with g++ 4.1) + */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator=(const ArrayBase& other) + { + internal::call_assignment(derived(), other.derived()); + return derived(); + } + + /** Set all the entries to \a value. + * \sa DenseBase::setConstant(), DenseBase::fill() */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator=(const Scalar &value) + { Base::setConstant(value); return derived(); } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator+=(const Scalar& scalar); + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator-=(const Scalar& scalar); + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator+=(const ArrayBase& other); + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator-=(const ArrayBase& other); + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator*=(const ArrayBase& other); + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator/=(const ArrayBase& other); + + public: + EIGEN_DEVICE_FUNC + ArrayBase& array() { return *this; } + EIGEN_DEVICE_FUNC + const ArrayBase& array() const { return *this; } + + /** \returns an \link Eigen::MatrixBase Matrix \endlink expression of this array + * \sa MatrixBase::array() */ + EIGEN_DEVICE_FUNC + MatrixWrapper matrix() { return MatrixWrapper(derived()); } + EIGEN_DEVICE_FUNC + const MatrixWrapper matrix() const { return MatrixWrapper(derived()); } + +// template +// inline void evalTo(Dest& dst) const { dst = matrix(); } + + protected: + EIGEN_DEVICE_FUNC + ArrayBase() : Base() {} + + private: + explicit ArrayBase(Index); + ArrayBase(Index,Index); + template explicit ArrayBase(const ArrayBase&); + protected: + // mixing arrays and matrices is not legal + template Derived& operator+=(const MatrixBase& ) + {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;} + // mixing arrays and matrices is not legal + template Derived& operator-=(const MatrixBase& ) + {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;} +}; + +/** replaces \c *this by \c *this - \a other. + * + * \returns a reference to \c *this + */ +template +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & +ArrayBase::operator-=(const ArrayBase &other) +{ + call_assignment(derived(), other.derived(), internal::sub_assign_op()); + return derived(); +} + +/** replaces \c *this by \c *this + \a other. + * + * \returns a reference to \c *this + */ +template +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & +ArrayBase::operator+=(const ArrayBase& other) +{ + call_assignment(derived(), other.derived(), internal::add_assign_op()); + return derived(); +} + +/** replaces \c *this by \c *this * \a other coefficient wise. + * + * \returns a reference to \c *this + */ +template +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & +ArrayBase::operator*=(const ArrayBase& other) +{ + call_assignment(derived(), other.derived(), internal::mul_assign_op()); + return derived(); +} + +/** replaces \c *this by \c *this / \a other coefficient wise. + * + * \returns a reference to \c *this + */ +template +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & +ArrayBase::operator/=(const ArrayBase& other) +{ + call_assignment(derived(), other.derived(), internal::div_assign_op()); + return derived(); +} + +} // end namespace Eigen + +#endif // EIGEN_ARRAYBASE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/ArrayWrapper.h b/3rdparty/eigen3/Eigen/src/Core/ArrayWrapper.h new file mode 100644 index 0000000..688aadd --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/ArrayWrapper.h @@ -0,0 +1,209 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ARRAYWRAPPER_H +#define EIGEN_ARRAYWRAPPER_H + +namespace Eigen { + +/** \class ArrayWrapper + * \ingroup Core_Module + * + * \brief Expression of a mathematical vector or matrix as an array object + * + * This class is the return type of MatrixBase::array(), and most of the time + * this is the only way it is use. + * + * \sa MatrixBase::array(), class MatrixWrapper + */ + +namespace internal { +template +struct traits > + : public traits::type > +{ + typedef ArrayXpr XprKind; + // Let's remove NestByRefBit + enum { + Flags0 = traits::type >::Flags, + LvalueBitFlag = is_lvalue::value ? LvalueBit : 0, + Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag + }; +}; +} + +template +class ArrayWrapper : public ArrayBase > +{ + public: + typedef ArrayBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper) + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper) + typedef typename internal::remove_all::type NestedExpression; + + typedef typename internal::conditional< + internal::is_lvalue::value, + Scalar, + const Scalar + >::type ScalarWithConstIfNotLvalue; + + typedef typename internal::ref_selector::non_const_type NestedExpressionType; + + using Base::coeffRef; + + EIGEN_DEVICE_FUNC + explicit EIGEN_STRONG_INLINE ArrayWrapper(ExpressionType& matrix) : m_expression(matrix) {} + + EIGEN_DEVICE_FUNC + inline Index rows() const { return m_expression.rows(); } + EIGEN_DEVICE_FUNC + inline Index cols() const { return m_expression.cols(); } + EIGEN_DEVICE_FUNC + inline Index outerStride() const { return m_expression.outerStride(); } + EIGEN_DEVICE_FUNC + inline Index innerStride() const { return m_expression.innerStride(); } + + EIGEN_DEVICE_FUNC + inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); } + EIGEN_DEVICE_FUNC + inline const Scalar* data() const { return m_expression.data(); } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index rowId, Index colId) const + { + return m_expression.coeffRef(rowId, colId); + } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index index) const + { + return m_expression.coeffRef(index); + } + + template + EIGEN_DEVICE_FUNC + inline void evalTo(Dest& dst) const { dst = m_expression; } + + const typename internal::remove_all::type& + EIGEN_DEVICE_FUNC + nestedExpression() const + { + return m_expression; + } + + /** Forwards the resizing request to the nested expression + * \sa DenseBase::resize(Index) */ + EIGEN_DEVICE_FUNC + void resize(Index newSize) { m_expression.resize(newSize); } + /** Forwards the resizing request to the nested expression + * \sa DenseBase::resize(Index,Index)*/ + EIGEN_DEVICE_FUNC + void resize(Index rows, Index cols) { m_expression.resize(rows,cols); } + + protected: + NestedExpressionType m_expression; +}; + +/** \class MatrixWrapper + * \ingroup Core_Module + * + * \brief Expression of an array as a mathematical vector or matrix + * + * This class is the return type of ArrayBase::matrix(), and most of the time + * this is the only way it is use. + * + * \sa MatrixBase::matrix(), class ArrayWrapper + */ + +namespace internal { +template +struct traits > + : public traits::type > +{ + typedef MatrixXpr XprKind; + // Let's remove NestByRefBit + enum { + Flags0 = traits::type >::Flags, + LvalueBitFlag = is_lvalue::value ? LvalueBit : 0, + Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag + }; +}; +} + +template +class MatrixWrapper : public MatrixBase > +{ + public: + typedef MatrixBase > Base; + EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper) + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper) + typedef typename internal::remove_all::type NestedExpression; + + typedef typename internal::conditional< + internal::is_lvalue::value, + Scalar, + const Scalar + >::type ScalarWithConstIfNotLvalue; + + typedef typename internal::ref_selector::non_const_type NestedExpressionType; + + using Base::coeffRef; + + EIGEN_DEVICE_FUNC + explicit inline MatrixWrapper(ExpressionType& matrix) : m_expression(matrix) {} + + EIGEN_DEVICE_FUNC + inline Index rows() const { return m_expression.rows(); } + EIGEN_DEVICE_FUNC + inline Index cols() const { return m_expression.cols(); } + EIGEN_DEVICE_FUNC + inline Index outerStride() const { return m_expression.outerStride(); } + EIGEN_DEVICE_FUNC + inline Index innerStride() const { return m_expression.innerStride(); } + + EIGEN_DEVICE_FUNC + inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); } + EIGEN_DEVICE_FUNC + inline const Scalar* data() const { return m_expression.data(); } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index rowId, Index colId) const + { + return m_expression.derived().coeffRef(rowId, colId); + } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index index) const + { + return m_expression.coeffRef(index); + } + + EIGEN_DEVICE_FUNC + const typename internal::remove_all::type& + nestedExpression() const + { + return m_expression; + } + + /** Forwards the resizing request to the nested expression + * \sa DenseBase::resize(Index) */ + EIGEN_DEVICE_FUNC + void resize(Index newSize) { m_expression.resize(newSize); } + /** Forwards the resizing request to the nested expression + * \sa DenseBase::resize(Index,Index)*/ + EIGEN_DEVICE_FUNC + void resize(Index rows, Index cols) { m_expression.resize(rows,cols); } + + protected: + NestedExpressionType m_expression; +}; + +} // end namespace Eigen + +#endif // EIGEN_ARRAYWRAPPER_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Assign.h b/3rdparty/eigen3/Eigen/src/Core/Assign.h new file mode 100644 index 0000000..53806ba --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Assign.h @@ -0,0 +1,90 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2007 Michael Olbrich +// Copyright (C) 2006-2010 Benoit Jacob +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ASSIGN_H +#define EIGEN_ASSIGN_H + +namespace Eigen { + +template +template +EIGEN_STRONG_INLINE Derived& DenseBase + ::lazyAssign(const DenseBase& other) +{ + enum{ + SameType = internal::is_same::value + }; + + EIGEN_STATIC_ASSERT_LVALUE(Derived) + EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived) + EIGEN_STATIC_ASSERT(SameType,YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) + + eigen_assert(rows() == other.rows() && cols() == other.cols()); + internal::call_assignment_no_alias(derived(),other.derived()); + + return derived(); +} + +template +template +EIGEN_DEVICE_FUNC +EIGEN_STRONG_INLINE Derived& DenseBase::operator=(const DenseBase& other) +{ + internal::call_assignment(derived(), other.derived()); + return derived(); +} + +template +EIGEN_DEVICE_FUNC +EIGEN_STRONG_INLINE Derived& DenseBase::operator=(const DenseBase& other) +{ + internal::call_assignment(derived(), other.derived()); + return derived(); +} + +template +EIGEN_DEVICE_FUNC +EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const MatrixBase& other) +{ + internal::call_assignment(derived(), other.derived()); + return derived(); +} + +template +template +EIGEN_DEVICE_FUNC +EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const DenseBase& other) +{ + internal::call_assignment(derived(), other.derived()); + return derived(); +} + +template +template +EIGEN_DEVICE_FUNC +EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const EigenBase& other) +{ + internal::call_assignment(derived(), other.derived()); + return derived(); +} + +template +template +EIGEN_DEVICE_FUNC +EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const ReturnByValue& other) +{ + other.derived().evalTo(derived()); + return derived(); +} + +} // end namespace Eigen + +#endif // EIGEN_ASSIGN_H diff --git a/3rdparty/eigen3/Eigen/src/Core/AssignEvaluator.h b/3rdparty/eigen3/Eigen/src/Core/AssignEvaluator.h new file mode 100644 index 0000000..dbe435d --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/AssignEvaluator.h @@ -0,0 +1,935 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2011 Benoit Jacob +// Copyright (C) 2011-2014 Gael Guennebaud +// Copyright (C) 2011-2012 Jitse Niesen +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ASSIGN_EVALUATOR_H +#define EIGEN_ASSIGN_EVALUATOR_H + +namespace Eigen { + +// This implementation is based on Assign.h + +namespace internal { + +/*************************************************************************** +* Part 1 : the logic deciding a strategy for traversal and unrolling * +***************************************************************************/ + +// copy_using_evaluator_traits is based on assign_traits + +template +struct copy_using_evaluator_traits +{ + typedef typename DstEvaluator::XprType Dst; + typedef typename Dst::Scalar DstScalar; + + enum { + DstFlags = DstEvaluator::Flags, + SrcFlags = SrcEvaluator::Flags + }; + +public: + enum { + DstAlignment = DstEvaluator::Alignment, + SrcAlignment = SrcEvaluator::Alignment, + DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit, + JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment) + }; + +private: + enum { + InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime) + : int(DstFlags)&RowMajorBit ? int(Dst::ColsAtCompileTime) + : int(Dst::RowsAtCompileTime), + InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime) + : int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime) + : int(Dst::MaxRowsAtCompileTime), + OuterStride = int(outer_stride_at_compile_time::ret), + MaxSizeAtCompileTime = Dst::SizeAtCompileTime + }; + + // TODO distinguish between linear traversal and inner-traversals + typedef typename find_best_packet::type LinearPacketType; + typedef typename find_best_packet::type InnerPacketType; + + enum { + LinearPacketSize = unpacket_traits::size, + InnerPacketSize = unpacket_traits::size + }; + +public: + enum { + LinearRequiredAlignment = unpacket_traits::alignment, + InnerRequiredAlignment = unpacket_traits::alignment + }; + +private: + enum { + DstIsRowMajor = DstFlags&RowMajorBit, + SrcIsRowMajor = SrcFlags&RowMajorBit, + StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)), + MightVectorize = bool(StorageOrdersAgree) + && (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit) + && bool(functor_traits::PacketAccess), + MayInnerVectorize = MightVectorize + && int(InnerSize)!=Dynamic && int(InnerSize)%int(InnerPacketSize)==0 + && int(OuterStride)!=Dynamic && int(OuterStride)%int(InnerPacketSize)==0 + && (EIGEN_UNALIGNED_VECTORIZE || int(JointAlignment)>=int(InnerRequiredAlignment)), + MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit), + MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess) + && (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)) || MaxSizeAtCompileTime == Dynamic), + /* If the destination isn't aligned, we have to do runtime checks and we don't unroll, + so it's only good for large enough sizes. */ + MaySliceVectorize = bool(MightVectorize) && bool(DstHasDirectAccess) + && (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=(EIGEN_UNALIGNED_VECTORIZE?InnerPacketSize:(3*InnerPacketSize))) + /* slice vectorization can be slow, so we only want it if the slices are big, which is + indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block + in a fixed-size matrix + However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */ + }; + +public: + enum { + Traversal = int(MayLinearVectorize) && (LinearPacketSize>InnerPacketSize) ? int(LinearVectorizedTraversal) + : int(MayInnerVectorize) ? int(InnerVectorizedTraversal) + : int(MayLinearVectorize) ? int(LinearVectorizedTraversal) + : int(MaySliceVectorize) ? int(SliceVectorizedTraversal) + : int(MayLinearize) ? int(LinearTraversal) + : int(DefaultTraversal), + Vectorized = int(Traversal) == InnerVectorizedTraversal + || int(Traversal) == LinearVectorizedTraversal + || int(Traversal) == SliceVectorizedTraversal + }; + + typedef typename conditional::type PacketType; + +private: + enum { + ActualPacketSize = int(Traversal)==LinearVectorizedTraversal ? LinearPacketSize + : Vectorized ? InnerPacketSize + : 1, + UnrollingLimit = EIGEN_UNROLLING_LIMIT * ActualPacketSize, + MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic + && int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit), + MayUnrollInner = int(InnerSize) != Dynamic + && int(InnerSize) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit) + }; + +public: + enum { + Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal)) + ? ( + int(MayUnrollCompletely) ? int(CompleteUnrolling) + : int(MayUnrollInner) ? int(InnerUnrolling) + : int(NoUnrolling) + ) + : int(Traversal) == int(LinearVectorizedTraversal) + ? ( bool(MayUnrollCompletely) && ( EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment))) + ? int(CompleteUnrolling) + : int(NoUnrolling) ) + : int(Traversal) == int(LinearTraversal) + ? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling) + : int(NoUnrolling) ) +#if EIGEN_UNALIGNED_VECTORIZE + : int(Traversal) == int(SliceVectorizedTraversal) + ? ( bool(MayUnrollInner) ? int(InnerUnrolling) + : int(NoUnrolling) ) +#endif + : int(NoUnrolling) + }; + +#ifdef EIGEN_DEBUG_ASSIGN + static void debug() + { + std::cerr << "DstXpr: " << typeid(typename DstEvaluator::XprType).name() << std::endl; + std::cerr << "SrcXpr: " << typeid(typename SrcEvaluator::XprType).name() << std::endl; + std::cerr.setf(std::ios::hex, std::ios::basefield); + std::cerr << "DstFlags" << " = " << DstFlags << " (" << demangle_flags(DstFlags) << " )" << std::endl; + std::cerr << "SrcFlags" << " = " << SrcFlags << " (" << demangle_flags(SrcFlags) << " )" << std::endl; + std::cerr.unsetf(std::ios::hex); + EIGEN_DEBUG_VAR(DstAlignment) + EIGEN_DEBUG_VAR(SrcAlignment) + EIGEN_DEBUG_VAR(LinearRequiredAlignment) + EIGEN_DEBUG_VAR(InnerRequiredAlignment) + EIGEN_DEBUG_VAR(JointAlignment) + EIGEN_DEBUG_VAR(InnerSize) + EIGEN_DEBUG_VAR(InnerMaxSize) + EIGEN_DEBUG_VAR(LinearPacketSize) + EIGEN_DEBUG_VAR(InnerPacketSize) + EIGEN_DEBUG_VAR(ActualPacketSize) + EIGEN_DEBUG_VAR(StorageOrdersAgree) + EIGEN_DEBUG_VAR(MightVectorize) + EIGEN_DEBUG_VAR(MayLinearize) + EIGEN_DEBUG_VAR(MayInnerVectorize) + EIGEN_DEBUG_VAR(MayLinearVectorize) + EIGEN_DEBUG_VAR(MaySliceVectorize) + std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl; + EIGEN_DEBUG_VAR(SrcEvaluator::CoeffReadCost) + EIGEN_DEBUG_VAR(UnrollingLimit) + EIGEN_DEBUG_VAR(MayUnrollCompletely) + EIGEN_DEBUG_VAR(MayUnrollInner) + std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl; + std::cerr << std::endl; + } +#endif +}; + +/*************************************************************************** +* Part 2 : meta-unrollers +***************************************************************************/ + +/************************ +*** Default traversal *** +************************/ + +template +struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling +{ + // FIXME: this is not very clean, perhaps this information should be provided by the kernel? + typedef typename Kernel::DstEvaluatorType DstEvaluatorType; + typedef typename DstEvaluatorType::XprType DstXprType; + + enum { + outer = Index / DstXprType::InnerSizeAtCompileTime, + inner = Index % DstXprType::InnerSizeAtCompileTime + }; + + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + kernel.assignCoeffByOuterInner(outer, inner); + copy_using_evaluator_DefaultTraversal_CompleteUnrolling::run(kernel); + } +}; + +template +struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { } +}; + +template +struct copy_using_evaluator_DefaultTraversal_InnerUnrolling +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer) + { + kernel.assignCoeffByOuterInner(outer, Index_); + copy_using_evaluator_DefaultTraversal_InnerUnrolling::run(kernel, outer); + } +}; + +template +struct copy_using_evaluator_DefaultTraversal_InnerUnrolling +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index) { } +}; + +/*********************** +*** Linear traversal *** +***********************/ + +template +struct copy_using_evaluator_LinearTraversal_CompleteUnrolling +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel) + { + kernel.assignCoeff(Index); + copy_using_evaluator_LinearTraversal_CompleteUnrolling::run(kernel); + } +}; + +template +struct copy_using_evaluator_LinearTraversal_CompleteUnrolling +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { } +}; + +/************************** +*** Inner vectorization *** +**************************/ + +template +struct copy_using_evaluator_innervec_CompleteUnrolling +{ + // FIXME: this is not very clean, perhaps this information should be provided by the kernel? + typedef typename Kernel::DstEvaluatorType DstEvaluatorType; + typedef typename DstEvaluatorType::XprType DstXprType; + typedef typename Kernel::PacketType PacketType; + + enum { + outer = Index / DstXprType::InnerSizeAtCompileTime, + inner = Index % DstXprType::InnerSizeAtCompileTime, + SrcAlignment = Kernel::AssignmentTraits::SrcAlignment, + DstAlignment = Kernel::AssignmentTraits::DstAlignment + }; + + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + kernel.template assignPacketByOuterInner(outer, inner); + enum { NextIndex = Index + unpacket_traits::size }; + copy_using_evaluator_innervec_CompleteUnrolling::run(kernel); + } +}; + +template +struct copy_using_evaluator_innervec_CompleteUnrolling +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { } +}; + +template +struct copy_using_evaluator_innervec_InnerUnrolling +{ + typedef typename Kernel::PacketType PacketType; + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer) + { + kernel.template assignPacketByOuterInner(outer, Index_); + enum { NextIndex = Index_ + unpacket_traits::size }; + copy_using_evaluator_innervec_InnerUnrolling::run(kernel, outer); + } +}; + +template +struct copy_using_evaluator_innervec_InnerUnrolling +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &, Index) { } +}; + +/*************************************************************************** +* Part 3 : implementation of all cases +***************************************************************************/ + +// dense_assignment_loop is based on assign_impl + +template +struct dense_assignment_loop; + +/************************ +*** Default traversal *** +************************/ + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel &kernel) + { + for(Index outer = 0; outer < kernel.outerSize(); ++outer) { + for(Index inner = 0; inner < kernel.innerSize(); ++inner) { + kernel.assignCoeffByOuterInner(outer, inner); + } + } + } +}; + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::DstEvaluatorType::XprType DstXprType; + copy_using_evaluator_DefaultTraversal_CompleteUnrolling::run(kernel); + } +}; + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::DstEvaluatorType::XprType DstXprType; + + const Index outerSize = kernel.outerSize(); + for(Index outer = 0; outer < outerSize; ++outer) + copy_using_evaluator_DefaultTraversal_InnerUnrolling::run(kernel, outer); + } +}; + +/*************************** +*** Linear vectorization *** +***************************/ + + +// The goal of unaligned_dense_assignment_loop is simply to factorize the handling +// of the non vectorizable beginning and ending parts + +template +struct unaligned_dense_assignment_loop +{ + // if IsAligned = true, then do nothing + template + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index, Index) {} +}; + +template <> +struct unaligned_dense_assignment_loop +{ + // MSVC must not inline this functions. If it does, it fails to optimize the + // packet access path. + // FIXME check which version exhibits this issue +#if EIGEN_COMP_MSVC + template + static EIGEN_DONT_INLINE void run(Kernel &kernel, + Index start, + Index end) +#else + template + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, + Index start, + Index end) +#endif + { + for (Index index = start; index < end; ++index) + kernel.assignCoeff(index); + } +}; + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + const Index size = kernel.size(); + typedef typename Kernel::Scalar Scalar; + typedef typename Kernel::PacketType PacketType; + enum { + requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment, + packetSize = unpacket_traits::size, + dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment), + dstAlignment = packet_traits::AlignedOnScalar ? int(requestedAlignment) + : int(Kernel::AssignmentTraits::DstAlignment), + srcAlignment = Kernel::AssignmentTraits::JointAlignment + }; + const Index alignedStart = dstIsAligned ? 0 : internal::first_aligned(kernel.dstDataPtr(), size); + const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize; + + unaligned_dense_assignment_loop::run(kernel, 0, alignedStart); + + for(Index index = alignedStart; index < alignedEnd; index += packetSize) + kernel.template assignPacket(index); + + unaligned_dense_assignment_loop<>::run(kernel, alignedEnd, size); + } +}; + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::DstEvaluatorType::XprType DstXprType; + typedef typename Kernel::PacketType PacketType; + + enum { size = DstXprType::SizeAtCompileTime, + packetSize =unpacket_traits::size, + alignedSize = (size/packetSize)*packetSize }; + + copy_using_evaluator_innervec_CompleteUnrolling::run(kernel); + copy_using_evaluator_DefaultTraversal_CompleteUnrolling::run(kernel); + } +}; + +/************************** +*** Inner vectorization *** +**************************/ + +template +struct dense_assignment_loop +{ + typedef typename Kernel::PacketType PacketType; + enum { + SrcAlignment = Kernel::AssignmentTraits::SrcAlignment, + DstAlignment = Kernel::AssignmentTraits::DstAlignment + }; + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + const Index innerSize = kernel.innerSize(); + const Index outerSize = kernel.outerSize(); + const Index packetSize = unpacket_traits::size; + for(Index outer = 0; outer < outerSize; ++outer) + for(Index inner = 0; inner < innerSize; inner+=packetSize) + kernel.template assignPacketByOuterInner(outer, inner); + } +}; + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::DstEvaluatorType::XprType DstXprType; + copy_using_evaluator_innervec_CompleteUnrolling::run(kernel); + } +}; + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::DstEvaluatorType::XprType DstXprType; + typedef typename Kernel::AssignmentTraits Traits; + const Index outerSize = kernel.outerSize(); + for(Index outer = 0; outer < outerSize; ++outer) + copy_using_evaluator_innervec_InnerUnrolling::run(kernel, outer); + } +}; + +/*********************** +*** Linear traversal *** +***********************/ + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + const Index size = kernel.size(); + for(Index i = 0; i < size; ++i) + kernel.assignCoeff(i); + } +}; + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::DstEvaluatorType::XprType DstXprType; + copy_using_evaluator_LinearTraversal_CompleteUnrolling::run(kernel); + } +}; + +/************************** +*** Slice vectorization *** +***************************/ + +template +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::Scalar Scalar; + typedef typename Kernel::PacketType PacketType; + enum { + packetSize = unpacket_traits::size, + requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment), + alignable = packet_traits::AlignedOnScalar || int(Kernel::AssignmentTraits::DstAlignment)>=sizeof(Scalar), + dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment), + dstAlignment = alignable ? int(requestedAlignment) + : int(Kernel::AssignmentTraits::DstAlignment) + }; + const Scalar *dst_ptr = kernel.dstDataPtr(); + if((!bool(dstIsAligned)) && (UIntPtr(dst_ptr) % sizeof(Scalar))>0) + { + // the pointer is not aligend-on scalar, so alignment is not possible + return dense_assignment_loop::run(kernel); + } + const Index packetAlignedMask = packetSize - 1; + const Index innerSize = kernel.innerSize(); + const Index outerSize = kernel.outerSize(); + const Index alignedStep = alignable ? (packetSize - kernel.outerStride() % packetSize) & packetAlignedMask : 0; + Index alignedStart = ((!alignable) || bool(dstIsAligned)) ? 0 : internal::first_aligned(dst_ptr, innerSize); + + for(Index outer = 0; outer < outerSize; ++outer) + { + const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask); + // do the non-vectorizable part of the assignment + for(Index inner = 0; inner(outer, inner); + + // do the non-vectorizable part of the assignment + for(Index inner = alignedEnd; inner +struct dense_assignment_loop +{ + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel) + { + typedef typename Kernel::DstEvaluatorType::XprType DstXprType; + typedef typename Kernel::PacketType PacketType; + + enum { size = DstXprType::InnerSizeAtCompileTime, + packetSize =unpacket_traits::size, + vectorizableSize = (size/packetSize)*packetSize }; + + for(Index outer = 0; outer < kernel.outerSize(); ++outer) + { + copy_using_evaluator_innervec_InnerUnrolling::run(kernel, outer); + copy_using_evaluator_DefaultTraversal_InnerUnrolling::run(kernel, outer); + } + } +}; +#endif + + +/*************************************************************************** +* Part 4 : Generic dense assignment kernel +***************************************************************************/ + +// This class generalize the assignment of a coefficient (or packet) from one dense evaluator +// to another dense writable evaluator. +// It is parametrized by the two evaluators, and the actual assignment functor. +// This abstraction level permits to keep the evaluation loops as simple and as generic as possible. +// One can customize the assignment using this generic dense_assignment_kernel with different +// functors, or by completely overloading it, by-passing a functor. +template +class generic_dense_assignment_kernel +{ +protected: + typedef typename DstEvaluatorTypeT::XprType DstXprType; + typedef typename SrcEvaluatorTypeT::XprType SrcXprType; +public: + + typedef DstEvaluatorTypeT DstEvaluatorType; + typedef SrcEvaluatorTypeT SrcEvaluatorType; + typedef typename DstEvaluatorType::Scalar Scalar; + typedef copy_using_evaluator_traits AssignmentTraits; + typedef typename AssignmentTraits::PacketType PacketType; + + + EIGEN_DEVICE_FUNC generic_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr) + : m_dst(dst), m_src(src), m_functor(func), m_dstExpr(dstExpr) + { + #ifdef EIGEN_DEBUG_ASSIGN + AssignmentTraits::debug(); + #endif + } + + EIGEN_DEVICE_FUNC Index size() const { return m_dstExpr.size(); } + EIGEN_DEVICE_FUNC Index innerSize() const { return m_dstExpr.innerSize(); } + EIGEN_DEVICE_FUNC Index outerSize() const { return m_dstExpr.outerSize(); } + EIGEN_DEVICE_FUNC Index rows() const { return m_dstExpr.rows(); } + EIGEN_DEVICE_FUNC Index cols() const { return m_dstExpr.cols(); } + EIGEN_DEVICE_FUNC Index outerStride() const { return m_dstExpr.outerStride(); } + + EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() { return m_dst; } + EIGEN_DEVICE_FUNC const SrcEvaluatorType& srcEvaluator() const { return m_src; } + + /// Assign src(row,col) to dst(row,col) through the assignment functor. + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index row, Index col) + { + m_functor.assignCoeff(m_dst.coeffRef(row,col), m_src.coeff(row,col)); + } + + /// \sa assignCoeff(Index,Index) + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index index) + { + m_functor.assignCoeff(m_dst.coeffRef(index), m_src.coeff(index)); + } + + /// \sa assignCoeff(Index,Index) + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeffByOuterInner(Index outer, Index inner) + { + Index row = rowIndexByOuterInner(outer, inner); + Index col = colIndexByOuterInner(outer, inner); + assignCoeff(row, col); + } + + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index row, Index col) + { + m_functor.template assignPacket(&m_dst.coeffRef(row,col), m_src.template packet(row,col)); + } + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index index) + { + m_functor.template assignPacket(&m_dst.coeffRef(index), m_src.template packet(index)); + } + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner) + { + Index row = rowIndexByOuterInner(outer, inner); + Index col = colIndexByOuterInner(outer, inner); + assignPacket(row, col); + } + + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) + { + typedef typename DstEvaluatorType::ExpressionTraits Traits; + return int(Traits::RowsAtCompileTime) == 1 ? 0 + : int(Traits::ColsAtCompileTime) == 1 ? inner + : int(DstEvaluatorType::Flags)&RowMajorBit ? outer + : inner; + } + + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) + { + typedef typename DstEvaluatorType::ExpressionTraits Traits; + return int(Traits::ColsAtCompileTime) == 1 ? 0 + : int(Traits::RowsAtCompileTime) == 1 ? inner + : int(DstEvaluatorType::Flags)&RowMajorBit ? inner + : outer; + } + + EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const + { + return m_dstExpr.data(); + } + +protected: + DstEvaluatorType& m_dst; + const SrcEvaluatorType& m_src; + const Functor &m_functor; + // TODO find a way to avoid the needs of the original expression + DstXprType& m_dstExpr; +}; + +/*************************************************************************** +* Part 5 : Entry point for dense rectangular assignment +***************************************************************************/ + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Functor &/*func*/) +{ + EIGEN_ONLY_USED_FOR_DEBUG(dst); + EIGEN_ONLY_USED_FOR_DEBUG(src); + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); +} + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op &/*func*/) +{ + Index dstRows = src.rows(); + Index dstCols = src.cols(); + if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols))) + dst.resize(dstRows, dstCols); + eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols); +} + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func) +{ + typedef evaluator DstEvaluatorType; + typedef evaluator SrcEvaluatorType; + + SrcEvaluatorType srcEvaluator(src); + + // NOTE To properly handle A = (A*A.transpose())/s with A rectangular, + // we need to resize the destination after the source evaluator has been created. + resize_if_allowed(dst, src, func); + + DstEvaluatorType dstEvaluator(dst); + + typedef generic_dense_assignment_kernel Kernel; + Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived()); + + dense_assignment_loop::run(kernel); +} + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src) +{ + call_dense_assignment_loop(dst, src, internal::assign_op()); +} + +/*************************************************************************** +* Part 6 : Generic assignment +***************************************************************************/ + +// Based on the respective shapes of the destination and source, +// the class AssignmentKind determine the kind of assignment mechanism. +// AssignmentKind must define a Kind typedef. +template struct AssignmentKind; + +// Assignement kind defined in this file: +struct Dense2Dense {}; +struct EigenBase2EigenBase {}; + +template struct AssignmentKind { typedef EigenBase2EigenBase Kind; }; +template<> struct AssignmentKind { typedef Dense2Dense Kind; }; + +// This is the main assignment class +template< typename DstXprType, typename SrcXprType, typename Functor, + typename Kind = typename AssignmentKind< typename evaluator_traits::Shape , typename evaluator_traits::Shape >::Kind, + typename EnableIf = void> +struct Assignment; + + +// The only purpose of this call_assignment() function is to deal with noalias() / "assume-aliasing" and automatic transposition. +// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated. +// So this intermediate function removes everything related to "assume-aliasing" such that Assignment +// does not has to bother about these annoying details. + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment(Dst& dst, const Src& src) +{ + call_assignment(dst, src, internal::assign_op()); +} +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment(const Dst& dst, const Src& src) +{ + call_assignment(dst, src, internal::assign_op()); +} + +// Deal with "assume-aliasing" +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing::value, void*>::type = 0) +{ + typename plain_matrix_type::type tmp(src); + call_assignment_no_alias(dst, tmp, func); +} + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if::value, void*>::type = 0) +{ + call_assignment_no_alias(dst, src, func); +} + +// by-pass "assume-aliasing" +// When there is no aliasing, we require that 'dst' has been properly resized +template class StorageBase, typename Src, typename Func> +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment(NoAlias& dst, const Src& src, const Func& func) +{ + call_assignment_no_alias(dst.expression(), src, func); +} + + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func) +{ + enum { + NeedToTranspose = ( (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1) + || (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1) + ) && int(Dst::SizeAtCompileTime) != 1 + }; + + typedef typename internal::conditional, Dst>::type ActualDstTypeCleaned; + typedef typename internal::conditional, Dst&>::type ActualDstType; + ActualDstType actualDst(dst); + + // TODO check whether this is the right place to perform these checks: + EIGEN_STATIC_ASSERT_LVALUE(Dst) + EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned,Src) + EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar); + + Assignment::run(actualDst, src, func); +} +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment_no_alias(Dst& dst, const Src& src) +{ + call_assignment_no_alias(dst, src, internal::assign_op()); +} + +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func) +{ + // TODO check whether this is the right place to perform these checks: + EIGEN_STATIC_ASSERT_LVALUE(Dst) + EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src) + EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar); + + Assignment::run(dst, src, func); +} +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE +void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src) +{ + call_assignment_no_alias_no_transpose(dst, src, internal::assign_op()); +} + +// forward declaration +template void check_for_aliasing(const Dst &dst, const Src &src); + +// Generic Dense to Dense assignment +// Note that the last template argument "Weak" is needed to make it possible to perform +// both partial specialization+SFINAE without ambiguous specialization +template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak> +struct Assignment +{ + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const Functor &func) + { +#ifndef EIGEN_NO_DEBUG + internal::check_for_aliasing(dst, src); +#endif + + call_dense_assignment_loop(dst, src, func); + } +}; + +// Generic assignment through evalTo. +// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism. +// Note that the last template argument "Weak" is needed to make it possible to perform +// both partial specialization+SFINAE without ambiguous specialization +template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak> +struct Assignment +{ + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op &/*func*/) + { + Index dstRows = src.rows(); + Index dstCols = src.cols(); + if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) + dst.resize(dstRows, dstCols); + + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); + src.evalTo(dst); + } + + // NOTE The following two functions are templated to avoid their instanciation if not needed + // This is needed because some expressions supports evalTo only and/or have 'void' as scalar type. + template + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op &/*func*/) + { + Index dstRows = src.rows(); + Index dstCols = src.cols(); + if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) + dst.resize(dstRows, dstCols); + + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); + src.addTo(dst); + } + + template + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op &/*func*/) + { + Index dstRows = src.rows(); + Index dstCols = src.cols(); + if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) + dst.resize(dstRows, dstCols); + + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); + src.subTo(dst); + } +}; + +} // namespace internal + +} // end namespace Eigen + +#endif // EIGEN_ASSIGN_EVALUATOR_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Assign_MKL.h b/3rdparty/eigen3/Eigen/src/Core/Assign_MKL.h new file mode 100755 index 0000000..6866095 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Assign_MKL.h @@ -0,0 +1,178 @@ +/* + Copyright (c) 2011, Intel Corporation. All rights reserved. + Copyright (C) 2015 Gael Guennebaud + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + ******************************************************************************** + * Content : Eigen bindings to Intel(R) MKL + * MKL VML support for coefficient-wise unary Eigen expressions like a=b.sin() + ******************************************************************************** +*/ + +#ifndef EIGEN_ASSIGN_VML_H +#define EIGEN_ASSIGN_VML_H + +namespace Eigen { + +namespace internal { + +template +class vml_assign_traits +{ + private: + enum { + DstHasDirectAccess = Dst::Flags & DirectAccessBit, + SrcHasDirectAccess = Src::Flags & DirectAccessBit, + StorageOrdersAgree = (int(Dst::IsRowMajor) == int(Src::IsRowMajor)), + InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime) + : int(Dst::Flags)&RowMajorBit ? int(Dst::ColsAtCompileTime) + : int(Dst::RowsAtCompileTime), + InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime) + : int(Dst::Flags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime) + : int(Dst::MaxRowsAtCompileTime), + MaxSizeAtCompileTime = Dst::SizeAtCompileTime, + + MightEnableVml = StorageOrdersAgree && DstHasDirectAccess && SrcHasDirectAccess && Src::InnerStrideAtCompileTime==1 && Dst::InnerStrideAtCompileTime==1, + MightLinearize = MightEnableVml && (int(Dst::Flags) & int(Src::Flags) & LinearAccessBit), + VmlSize = MightLinearize ? MaxSizeAtCompileTime : InnerMaxSize, + LargeEnough = VmlSize==Dynamic || VmlSize>=EIGEN_MKL_VML_THRESHOLD + }; + public: + enum { + EnableVml = MightEnableVml && LargeEnough, + Traversal = MightLinearize ? LinearTraversal : DefaultTraversal + }; +}; + +#define EIGEN_PP_EXPAND(ARG) ARG +#if !defined (EIGEN_FAST_MATH) || (EIGEN_FAST_MATH != 1) +#define EIGEN_VMLMODE_EXPAND_LA , VML_HA +#else +#define EIGEN_VMLMODE_EXPAND_LA , VML_LA +#endif + +#define EIGEN_VMLMODE_EXPAND__ + +#define EIGEN_VMLMODE_PREFIX_LA vm +#define EIGEN_VMLMODE_PREFIX__ v +#define EIGEN_VMLMODE_PREFIX(VMLMODE) EIGEN_CAT(EIGEN_VMLMODE_PREFIX_,VMLMODE) + +#define EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE) \ + template< typename DstXprType, typename SrcXprNested> \ + struct Assignment, SrcXprNested>, assign_op, \ + Dense2Dense, typename enable_if::EnableVml>::type> { \ + typedef CwiseUnaryOp, SrcXprNested> SrcXprType; \ + static void run(DstXprType &dst, const SrcXprType &src, const assign_op &func) { \ + resize_if_allowed(dst, src, func); \ + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); \ + if(vml_assign_traits::Traversal==LinearTraversal) { \ + VMLOP(dst.size(), (const VMLTYPE*)src.nestedExpression().data(), \ + (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE) ); \ + } else { \ + const Index outerSize = dst.outerSize(); \ + for(Index outer = 0; outer < outerSize; ++outer) { \ + const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.nestedExpression().coeffRef(outer,0)) : \ + &(src.nestedExpression().coeffRef(0, outer)); \ + EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer)); \ + VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr, \ + (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE)); \ + } \ + } \ + } \ + }; \ + + +#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE) \ + EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),s##VMLOP), float, float, VMLMODE) \ + EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),d##VMLOP), double, double, VMLMODE) + +#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE) \ + EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),c##VMLOP), scomplex, MKL_Complex8, VMLMODE) \ + EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),z##VMLOP), dcomplex, MKL_Complex16, VMLMODE) + +#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS(EIGENOP, VMLOP, VMLMODE) \ + EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE) \ + EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE) + + +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sin, Sin, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(asin, Asin, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sinh, Sinh, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cos, Cos, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(acos, Acos, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cosh, Cosh, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tan, Tan, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(atan, Atan, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tanh, Tanh, LA) +// EIGEN_MKL_VML_DECLARE_UNARY_CALLS(abs, Abs, _) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(exp, Exp, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log, Ln, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log10, Log10, LA) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sqrt, Sqrt, _) + +EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(square, Sqr, _) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(arg, Arg, _) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(round, Round, _) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(floor, Floor, _) +EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(ceil, Ceil, _) + +#define EIGEN_MKL_VML_DECLARE_POW_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE) \ + template< typename DstXprType, typename SrcXprNested, typename Plain> \ + struct Assignment, SrcXprNested, \ + const CwiseNullaryOp,Plain> >, assign_op, \ + Dense2Dense, typename enable_if::EnableVml>::type> { \ + typedef CwiseBinaryOp, SrcXprNested, \ + const CwiseNullaryOp,Plain> > SrcXprType; \ + static void run(DstXprType &dst, const SrcXprType &src, const assign_op &func) { \ + resize_if_allowed(dst, src, func); \ + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); \ + VMLTYPE exponent = reinterpret_cast(src.rhs().functor().m_other); \ + if(vml_assign_traits::Traversal==LinearTraversal) \ + { \ + VMLOP( dst.size(), (const VMLTYPE*)src.lhs().data(), exponent, \ + (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE) ); \ + } else { \ + const Index outerSize = dst.outerSize(); \ + for(Index outer = 0; outer < outerSize; ++outer) { \ + const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.lhs().coeffRef(outer,0)) : \ + &(src.lhs().coeffRef(0, outer)); \ + EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer)); \ + VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr, exponent, \ + (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE)); \ + } \ + } \ + } \ + }; + +EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmsPowx, float, float, LA) +EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmdPowx, double, double, LA) +EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmcPowx, scomplex, MKL_Complex8, LA) +EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmzPowx, dcomplex, MKL_Complex16, LA) + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_ASSIGN_VML_H diff --git a/3rdparty/eigen3/Eigen/src/Core/BandMatrix.h b/3rdparty/eigen3/Eigen/src/Core/BandMatrix.h new file mode 100644 index 0000000..4978c91 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/BandMatrix.h @@ -0,0 +1,353 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_BANDMATRIX_H +#define EIGEN_BANDMATRIX_H + +namespace Eigen { + +namespace internal { + +template +class BandMatrixBase : public EigenBase +{ + public: + + enum { + Flags = internal::traits::Flags, + CoeffReadCost = internal::traits::CoeffReadCost, + RowsAtCompileTime = internal::traits::RowsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, + MaxRowsAtCompileTime = internal::traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = internal::traits::MaxColsAtCompileTime, + Supers = internal::traits::Supers, + Subs = internal::traits::Subs, + Options = internal::traits::Options + }; + typedef typename internal::traits::Scalar Scalar; + typedef Matrix DenseMatrixType; + typedef typename DenseMatrixType::StorageIndex StorageIndex; + typedef typename internal::traits::CoefficientsType CoefficientsType; + typedef EigenBase Base; + + protected: + enum { + DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) + ? 1 + Supers + Subs + : Dynamic, + SizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime) + }; + + public: + + using Base::derived; + using Base::rows; + using Base::cols; + + /** \returns the number of super diagonals */ + inline Index supers() const { return derived().supers(); } + + /** \returns the number of sub diagonals */ + inline Index subs() const { return derived().subs(); } + + /** \returns an expression of the underlying coefficient matrix */ + inline const CoefficientsType& coeffs() const { return derived().coeffs(); } + + /** \returns an expression of the underlying coefficient matrix */ + inline CoefficientsType& coeffs() { return derived().coeffs(); } + + /** \returns a vector expression of the \a i -th column, + * only the meaningful part is returned. + * \warning the internal storage must be column major. */ + inline Block col(Index i) + { + EIGEN_STATIC_ASSERT((Options&RowMajor)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES); + Index start = 0; + Index len = coeffs().rows(); + if (i<=supers()) + { + start = supers()-i; + len = (std::min)(rows(),std::max(0,coeffs().rows() - (supers()-i))); + } + else if (i>=rows()-subs()) + len = std::max(0,coeffs().rows() - (i + 1 - rows() + subs())); + return Block(coeffs(), start, i, len, 1); + } + + /** \returns a vector expression of the main diagonal */ + inline Block diagonal() + { return Block(coeffs(),supers(),0,1,(std::min)(rows(),cols())); } + + /** \returns a vector expression of the main diagonal (const version) */ + inline const Block diagonal() const + { return Block(coeffs(),supers(),0,1,(std::min)(rows(),cols())); } + + template struct DiagonalIntReturnType { + enum { + ReturnOpposite = (Options&SelfAdjoint) && (((Index)>0 && Supers==0) || ((Index)<0 && Subs==0)), + Conjugate = ReturnOpposite && NumTraits::IsComplex, + ActualIndex = ReturnOpposite ? -Index : Index, + DiagonalSize = (RowsAtCompileTime==Dynamic || ColsAtCompileTime==Dynamic) + ? Dynamic + : (ActualIndex<0 + ? EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime, RowsAtCompileTime + ActualIndex) + : EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime - ActualIndex)) + }; + typedef Block BuildType; + typedef typename internal::conditional,BuildType >, + BuildType>::type Type; + }; + + /** \returns a vector expression of the \a N -th sub or super diagonal */ + template inline typename DiagonalIntReturnType::Type diagonal() + { + return typename DiagonalIntReturnType::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N)); + } + + /** \returns a vector expression of the \a N -th sub or super diagonal */ + template inline const typename DiagonalIntReturnType::Type diagonal() const + { + return typename DiagonalIntReturnType::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N)); + } + + /** \returns a vector expression of the \a i -th sub or super diagonal */ + inline Block diagonal(Index i) + { + eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); + return Block(coeffs(), supers()-i, std::max(0,i), 1, diagonalLength(i)); + } + + /** \returns a vector expression of the \a i -th sub or super diagonal */ + inline const Block diagonal(Index i) const + { + eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); + return Block(coeffs(), supers()-i, std::max(0,i), 1, diagonalLength(i)); + } + + template inline void evalTo(Dest& dst) const + { + dst.resize(rows(),cols()); + dst.setZero(); + dst.diagonal() = diagonal(); + for (Index i=1; i<=supers();++i) + dst.diagonal(i) = diagonal(i); + for (Index i=1; i<=subs();++i) + dst.diagonal(-i) = diagonal(-i); + } + + DenseMatrixType toDenseMatrix() const + { + DenseMatrixType res(rows(),cols()); + evalTo(res); + return res; + } + + protected: + + inline Index diagonalLength(Index i) const + { return i<0 ? (std::min)(cols(),rows()+i) : (std::min)(rows(),cols()-i); } +}; + +/** + * \class BandMatrix + * \ingroup Core_Module + * + * \brief Represents a rectangular matrix with a banded storage + * + * \tparam _Scalar Numeric type, i.e. float, double, int + * \tparam _Rows Number of rows, or \b Dynamic + * \tparam _Cols Number of columns, or \b Dynamic + * \tparam _Supers Number of super diagonal + * \tparam _Subs Number of sub diagonal + * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of \b #SelfAdjoint + * The former controls \ref TopicStorageOrders "storage order", and defaults to + * column-major. The latter controls whether the matrix represents a selfadjoint + * matrix in which case either Supers of Subs have to be null. + * + * \sa class TridiagonalMatrix + */ + +template +struct traits > +{ + typedef _Scalar Scalar; + typedef Dense StorageKind; + typedef Eigen::Index StorageIndex; + enum { + CoeffReadCost = NumTraits::ReadCost, + RowsAtCompileTime = _Rows, + ColsAtCompileTime = _Cols, + MaxRowsAtCompileTime = _Rows, + MaxColsAtCompileTime = _Cols, + Flags = LvalueBit, + Supers = _Supers, + Subs = _Subs, + Options = _Options, + DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic + }; + typedef Matrix CoefficientsType; +}; + +template +class BandMatrix : public BandMatrixBase > +{ + public: + + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::traits::StorageIndex StorageIndex; + typedef typename internal::traits::CoefficientsType CoefficientsType; + + explicit inline BandMatrix(Index rows=Rows, Index cols=Cols, Index supers=Supers, Index subs=Subs) + : m_coeffs(1+supers+subs,cols), + m_rows(rows), m_supers(supers), m_subs(subs) + { + } + + /** \returns the number of columns */ + inline Index rows() const { return m_rows.value(); } + + /** \returns the number of rows */ + inline Index cols() const { return m_coeffs.cols(); } + + /** \returns the number of super diagonals */ + inline Index supers() const { return m_supers.value(); } + + /** \returns the number of sub diagonals */ + inline Index subs() const { return m_subs.value(); } + + inline const CoefficientsType& coeffs() const { return m_coeffs; } + inline CoefficientsType& coeffs() { return m_coeffs; } + + protected: + + CoefficientsType m_coeffs; + internal::variable_if_dynamic m_rows; + internal::variable_if_dynamic m_supers; + internal::variable_if_dynamic m_subs; +}; + +template +class BandMatrixWrapper; + +template +struct traits > +{ + typedef typename _CoefficientsType::Scalar Scalar; + typedef typename _CoefficientsType::StorageKind StorageKind; + typedef typename _CoefficientsType::StorageIndex StorageIndex; + enum { + CoeffReadCost = internal::traits<_CoefficientsType>::CoeffReadCost, + RowsAtCompileTime = _Rows, + ColsAtCompileTime = _Cols, + MaxRowsAtCompileTime = _Rows, + MaxColsAtCompileTime = _Cols, + Flags = LvalueBit, + Supers = _Supers, + Subs = _Subs, + Options = _Options, + DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic + }; + typedef _CoefficientsType CoefficientsType; +}; + +template +class BandMatrixWrapper : public BandMatrixBase > +{ + public: + + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::traits::CoefficientsType CoefficientsType; + typedef typename internal::traits::StorageIndex StorageIndex; + + explicit inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows=_Rows, Index cols=_Cols, Index supers=_Supers, Index subs=_Subs) + : m_coeffs(coeffs), + m_rows(rows), m_supers(supers), m_subs(subs) + { + EIGEN_UNUSED_VARIABLE(cols); + //internal::assert(coeffs.cols()==cols() && (supers()+subs()+1)==coeffs.rows()); + } + + /** \returns the number of columns */ + inline Index rows() const { return m_rows.value(); } + + /** \returns the number of rows */ + inline Index cols() const { return m_coeffs.cols(); } + + /** \returns the number of super diagonals */ + inline Index supers() const { return m_supers.value(); } + + /** \returns the number of sub diagonals */ + inline Index subs() const { return m_subs.value(); } + + inline const CoefficientsType& coeffs() const { return m_coeffs; } + + protected: + + const CoefficientsType& m_coeffs; + internal::variable_if_dynamic m_rows; + internal::variable_if_dynamic m_supers; + internal::variable_if_dynamic m_subs; +}; + +/** + * \class TridiagonalMatrix + * \ingroup Core_Module + * + * \brief Represents a tridiagonal matrix with a compact banded storage + * + * \tparam Scalar Numeric type, i.e. float, double, int + * \tparam Size Number of rows and cols, or \b Dynamic + * \tparam Options Can be 0 or \b SelfAdjoint + * + * \sa class BandMatrix + */ +template +class TridiagonalMatrix : public BandMatrix +{ + typedef BandMatrix Base; + typedef typename Base::StorageIndex StorageIndex; + public: + explicit TridiagonalMatrix(Index size = Size) : Base(size,size,Options&SelfAdjoint?0:1,1) {} + + inline typename Base::template DiagonalIntReturnType<1>::Type super() + { return Base::template diagonal<1>(); } + inline const typename Base::template DiagonalIntReturnType<1>::Type super() const + { return Base::template diagonal<1>(); } + inline typename Base::template DiagonalIntReturnType<-1>::Type sub() + { return Base::template diagonal<-1>(); } + inline const typename Base::template DiagonalIntReturnType<-1>::Type sub() const + { return Base::template diagonal<-1>(); } + protected: +}; + + +struct BandShape {}; + +template +struct evaluator_traits > + : public evaluator_traits_base > +{ + typedef BandShape Shape; +}; + +template +struct evaluator_traits > + : public evaluator_traits_base > +{ + typedef BandShape Shape; +}; + +template<> struct AssignmentKind { typedef EigenBase2EigenBase Kind; }; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_BANDMATRIX_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Block.h b/3rdparty/eigen3/Eigen/src/Core/Block.h new file mode 100644 index 0000000..11de45c --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Block.h @@ -0,0 +1,452 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2006-2010 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_BLOCK_H +#define EIGEN_BLOCK_H + +namespace Eigen { + +namespace internal { +template +struct traits > : traits +{ + typedef typename traits::Scalar Scalar; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; + typedef typename ref_selector::type XprTypeNested; + typedef typename remove_reference::type _XprTypeNested; + enum{ + MatrixRows = traits::RowsAtCompileTime, + MatrixCols = traits::ColsAtCompileTime, + RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows, + ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols, + MaxRowsAtCompileTime = BlockRows==0 ? 0 + : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime) + : int(traits::MaxRowsAtCompileTime), + MaxColsAtCompileTime = BlockCols==0 ? 0 + : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime) + : int(traits::MaxColsAtCompileTime), + + XprTypeIsRowMajor = (int(traits::Flags)&RowMajorBit) != 0, + IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1 + : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0 + : XprTypeIsRowMajor, + HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor), + InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime), + InnerStrideAtCompileTime = HasSameStorageOrderAsXprType + ? int(inner_stride_at_compile_time::ret) + : int(outer_stride_at_compile_time::ret), + OuterStrideAtCompileTime = HasSameStorageOrderAsXprType + ? int(outer_stride_at_compile_time::ret) + : int(inner_stride_at_compile_time::ret), + + // FIXME, this traits is rather specialized for dense object and it needs to be cleaned further + FlagsLvalueBit = is_lvalue::value ? LvalueBit : 0, + FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0, + Flags = (traits::Flags & (DirectAccessBit | (InnerPanel?CompressedAccessBit:0))) | FlagsLvalueBit | FlagsRowMajorBit, + // FIXME DirectAccessBit should not be handled by expressions + // + // Alignment is needed by MapBase's assertions + // We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the respective evaluator + Alignment = 0 + }; +}; + +template::ret> class BlockImpl_dense; + +} // end namespace internal + +template class BlockImpl; + +/** \class Block + * \ingroup Core_Module + * + * \brief Expression of a fixed-size or dynamic-size block + * + * \tparam XprType the type of the expression in which we are taking a block + * \tparam BlockRows the number of rows of the block we are taking at compile time (optional) + * \tparam BlockCols the number of columns of the block we are taking at compile time (optional) + * \tparam InnerPanel is true, if the block maps to a set of rows of a row major matrix or + * to set of columns of a column major matrix (optional). The parameter allows to determine + * at compile time whether aligned access is possible on the block expression. + * + * This class represents an expression of either a fixed-size or dynamic-size block. It is the return + * type of DenseBase::block(Index,Index,Index,Index) and DenseBase::block(Index,Index) and + * most of the time this is the only way it is used. + * + * However, if you want to directly maniputate block expressions, + * for instance if you want to write a function returning such an expression, you + * will need to use this class. + * + * Here is an example illustrating the dynamic case: + * \include class_Block.cpp + * Output: \verbinclude class_Block.out + * + * \note Even though this expression has dynamic size, in the case where \a XprType + * has fixed size, this expression inherits a fixed maximal size which means that evaluating + * it does not cause a dynamic memory allocation. + * + * Here is an example illustrating the fixed-size case: + * \include class_FixedBlock.cpp + * Output: \verbinclude class_FixedBlock.out + * + * \sa DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock + */ +template class Block + : public BlockImpl::StorageKind> +{ + typedef BlockImpl::StorageKind> Impl; + public: + //typedef typename Impl::Base Base; + typedef Impl Base; + EIGEN_GENERIC_PUBLIC_INTERFACE(Block) + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block) + + typedef typename internal::remove_all::type NestedExpression; + + /** Column or Row constructor + */ + EIGEN_DEVICE_FUNC + inline Block(XprType& xpr, Index i) : Impl(xpr,i) + { + eigen_assert( (i>=0) && ( + ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows() + && startCol >= 0 && BlockCols >= 0 && startCol + BlockCols <= xpr.cols()); + } + + /** Dynamic-size constructor + */ + EIGEN_DEVICE_FUNC + inline Block(XprType& xpr, + Index startRow, Index startCol, + Index blockRows, Index blockCols) + : Impl(xpr, startRow, startCol, blockRows, blockCols) + { + eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows) + && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols)); + eigen_assert(startRow >= 0 && blockRows >= 0 && startRow <= xpr.rows() - blockRows + && startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols); + } +}; + +// The generic default implementation for dense block simplu forward to the internal::BlockImpl_dense +// that must be specialized for direct and non-direct access... +template +class BlockImpl + : public internal::BlockImpl_dense +{ + typedef internal::BlockImpl_dense Impl; + typedef typename XprType::StorageIndex StorageIndex; + public: + typedef Impl Base; + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl) + EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {} + EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {} + EIGEN_DEVICE_FUNC + inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols) + : Impl(xpr, startRow, startCol, blockRows, blockCols) {} +}; + +namespace internal { + +/** \internal Internal implementation of dense Blocks in the general case. */ +template class BlockImpl_dense + : public internal::dense_xpr_base >::type +{ + typedef Block BlockType; + typedef typename internal::ref_selector::non_const_type XprTypeNested; + public: + + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(BlockType) + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense) + + // class InnerIterator; // FIXME apparently never used + + /** Column or Row constructor + */ + EIGEN_DEVICE_FUNC + inline BlockImpl_dense(XprType& xpr, Index i) + : m_xpr(xpr), + // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime, + // and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1, + // all other cases are invalid. + // The case a 1x1 matrix seems ambiguous, but the result is the same anyway. + m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0), + m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0), + m_blockRows(BlockRows==1 ? 1 : xpr.rows()), + m_blockCols(BlockCols==1 ? 1 : xpr.cols()) + {} + + /** Fixed-size constructor + */ + EIGEN_DEVICE_FUNC + inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol) + : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol), + m_blockRows(BlockRows), m_blockCols(BlockCols) + {} + + /** Dynamic-size constructor + */ + EIGEN_DEVICE_FUNC + inline BlockImpl_dense(XprType& xpr, + Index startRow, Index startCol, + Index blockRows, Index blockCols) + : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol), + m_blockRows(blockRows), m_blockCols(blockCols) + {} + + EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); } + EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); } + + EIGEN_DEVICE_FUNC + inline Scalar& coeffRef(Index rowId, Index colId) + { + EIGEN_STATIC_ASSERT_LVALUE(XprType) + return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value()); + } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index rowId, Index colId) const + { + return m_xpr.derived().coeffRef(rowId + m_startRow.value(), colId + m_startCol.value()); + } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const + { + return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value()); + } + + EIGEN_DEVICE_FUNC + inline Scalar& coeffRef(Index index) + { + EIGEN_STATIC_ASSERT_LVALUE(XprType) + return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index), + m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); + } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index index) const + { + return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index), + m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); + } + + EIGEN_DEVICE_FUNC + inline const CoeffReturnType coeff(Index index) const + { + return m_xpr.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index), + m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); + } + + template + inline PacketScalar packet(Index rowId, Index colId) const + { + return m_xpr.template packet(rowId + m_startRow.value(), colId + m_startCol.value()); + } + + template + inline void writePacket(Index rowId, Index colId, const PacketScalar& val) + { + m_xpr.template writePacket(rowId + m_startRow.value(), colId + m_startCol.value(), val); + } + + template + inline PacketScalar packet(Index index) const + { + return m_xpr.template packet + (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index), + m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); + } + + template + inline void writePacket(Index index, const PacketScalar& val) + { + m_xpr.template writePacket + (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index), + m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), val); + } + + #ifdef EIGEN_PARSED_BY_DOXYGEN + /** \sa MapBase::data() */ + EIGEN_DEVICE_FUNC inline const Scalar* data() const; + EIGEN_DEVICE_FUNC inline Index innerStride() const; + EIGEN_DEVICE_FUNC inline Index outerStride() const; + #endif + + EIGEN_DEVICE_FUNC + const typename internal::remove_all::type& nestedExpression() const + { + return m_xpr; + } + + EIGEN_DEVICE_FUNC + XprType& nestedExpression() { return m_xpr; } + + EIGEN_DEVICE_FUNC + StorageIndex startRow() const + { + return m_startRow.value(); + } + + EIGEN_DEVICE_FUNC + StorageIndex startCol() const + { + return m_startCol.value(); + } + + protected: + + XprTypeNested m_xpr; + const internal::variable_if_dynamic m_startRow; + const internal::variable_if_dynamic m_startCol; + const internal::variable_if_dynamic m_blockRows; + const internal::variable_if_dynamic m_blockCols; +}; + +/** \internal Internal implementation of dense Blocks in the direct access case.*/ +template +class BlockImpl_dense + : public MapBase > +{ + typedef Block BlockType; + typedef typename internal::ref_selector::non_const_type XprTypeNested; + enum { + XprTypeIsRowMajor = (int(traits::Flags)&RowMajorBit) != 0 + }; + public: + + typedef MapBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(BlockType) + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense) + + /** Column or Row constructor + */ + EIGEN_DEVICE_FUNC + inline BlockImpl_dense(XprType& xpr, Index i) + : Base(xpr.data() + i * ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && (!XprTypeIsRowMajor)) + || ((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && ( XprTypeIsRowMajor)) ? xpr.innerStride() : xpr.outerStride()), + BlockRows==1 ? 1 : xpr.rows(), + BlockCols==1 ? 1 : xpr.cols()), + m_xpr(xpr), + m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0), + m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0) + { + init(); + } + + /** Fixed-size constructor + */ + EIGEN_DEVICE_FUNC + inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol) + : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol)), + m_xpr(xpr), m_startRow(startRow), m_startCol(startCol) + { + init(); + } + + /** Dynamic-size constructor + */ + EIGEN_DEVICE_FUNC + inline BlockImpl_dense(XprType& xpr, + Index startRow, Index startCol, + Index blockRows, Index blockCols) + : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol), blockRows, blockCols), + m_xpr(xpr), m_startRow(startRow), m_startCol(startCol) + { + init(); + } + + EIGEN_DEVICE_FUNC + const typename internal::remove_all::type& nestedExpression() const + { + return m_xpr; + } + + EIGEN_DEVICE_FUNC + XprType& nestedExpression() { return m_xpr; } + + /** \sa MapBase::innerStride() */ + EIGEN_DEVICE_FUNC + inline Index innerStride() const + { + return internal::traits::HasSameStorageOrderAsXprType + ? m_xpr.innerStride() + : m_xpr.outerStride(); + } + + /** \sa MapBase::outerStride() */ + EIGEN_DEVICE_FUNC + inline Index outerStride() const + { + return m_outerStride; + } + + EIGEN_DEVICE_FUNC + StorageIndex startRow() const + { + return m_startRow.value(); + } + + EIGEN_DEVICE_FUNC + StorageIndex startCol() const + { + return m_startCol.value(); + } + + #ifndef __SUNPRO_CC + // FIXME sunstudio is not friendly with the above friend... + // META-FIXME there is no 'friend' keyword around here. Is this obsolete? + protected: + #endif + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** \internal used by allowAligned() */ + EIGEN_DEVICE_FUNC + inline BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols) + : Base(data, blockRows, blockCols), m_xpr(xpr) + { + init(); + } + #endif + + protected: + EIGEN_DEVICE_FUNC + void init() + { + m_outerStride = internal::traits::HasSameStorageOrderAsXprType + ? m_xpr.outerStride() + : m_xpr.innerStride(); + } + + XprTypeNested m_xpr; + const internal::variable_if_dynamic m_startRow; + const internal::variable_if_dynamic m_startCol; + Index m_outerStride; +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_BLOCK_H diff --git a/3rdparty/eigen3/Eigen/src/Core/BooleanRedux.h b/3rdparty/eigen3/Eigen/src/Core/BooleanRedux.h new file mode 100644 index 0000000..8409d87 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/BooleanRedux.h @@ -0,0 +1,164 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_ALLANDANY_H +#define EIGEN_ALLANDANY_H + +namespace Eigen { + +namespace internal { + +template +struct all_unroller +{ + typedef typename Derived::ExpressionTraits Traits; + enum { + col = (UnrollCount-1) / Traits::RowsAtCompileTime, + row = (UnrollCount-1) % Traits::RowsAtCompileTime + }; + + static inline bool run(const Derived &mat) + { + return all_unroller::run(mat) && mat.coeff(row, col); + } +}; + +template +struct all_unroller +{ + static inline bool run(const Derived &/*mat*/) { return true; } +}; + +template +struct all_unroller +{ + static inline bool run(const Derived &) { return false; } +}; + +template +struct any_unroller +{ + typedef typename Derived::ExpressionTraits Traits; + enum { + col = (UnrollCount-1) / Traits::RowsAtCompileTime, + row = (UnrollCount-1) % Traits::RowsAtCompileTime + }; + + static inline bool run(const Derived &mat) + { + return any_unroller::run(mat) || mat.coeff(row, col); + } +}; + +template +struct any_unroller +{ + static inline bool run(const Derived & /*mat*/) { return false; } +}; + +template +struct any_unroller +{ + static inline bool run(const Derived &) { return false; } +}; + +} // end namespace internal + +/** \returns true if all coefficients are true + * + * Example: \include MatrixBase_all.cpp + * Output: \verbinclude MatrixBase_all.out + * + * \sa any(), Cwise::operator<() + */ +template +inline bool DenseBase::all() const +{ + typedef internal::evaluator Evaluator; + enum { + unroll = SizeAtCompileTime != Dynamic + && SizeAtCompileTime * (Evaluator::CoeffReadCost + NumTraits::AddCost) <= EIGEN_UNROLLING_LIMIT + }; + Evaluator evaluator(derived()); + if(unroll) + return internal::all_unroller::run(evaluator); + else + { + for(Index j = 0; j < cols(); ++j) + for(Index i = 0; i < rows(); ++i) + if (!evaluator.coeff(i, j)) return false; + return true; + } +} + +/** \returns true if at least one coefficient is true + * + * \sa all() + */ +template +inline bool DenseBase::any() const +{ + typedef internal::evaluator Evaluator; + enum { + unroll = SizeAtCompileTime != Dynamic + && SizeAtCompileTime * (Evaluator::CoeffReadCost + NumTraits::AddCost) <= EIGEN_UNROLLING_LIMIT + }; + Evaluator evaluator(derived()); + if(unroll) + return internal::any_unroller::run(evaluator); + else + { + for(Index j = 0; j < cols(); ++j) + for(Index i = 0; i < rows(); ++i) + if (evaluator.coeff(i, j)) return true; + return false; + } +} + +/** \returns the number of coefficients which evaluate to true + * + * \sa all(), any() + */ +template +inline Eigen::Index DenseBase::count() const +{ + return derived().template cast().template cast().sum(); +} + +/** \returns true is \c *this contains at least one Not A Number (NaN). + * + * \sa allFinite() + */ +template +inline bool DenseBase::hasNaN() const +{ +#if EIGEN_COMP_MSVC || (defined __FAST_MATH__) + return derived().array().isNaN().any(); +#else + return !((derived().array()==derived().array()).all()); +#endif +} + +/** \returns true if \c *this contains only finite numbers, i.e., no NaN and no +/-INF values. + * + * \sa hasNaN() + */ +template +inline bool DenseBase::allFinite() const +{ +#if EIGEN_COMP_MSVC || (defined __FAST_MATH__) + return derived().array().isFinite().all(); +#else + return !((derived()-derived()).hasNaN()); +#endif +} + +} // end namespace Eigen + +#endif // EIGEN_ALLANDANY_H diff --git a/3rdparty/eigen3/Eigen/src/Core/CommaInitializer.h b/3rdparty/eigen3/Eigen/src/Core/CommaInitializer.h new file mode 100644 index 0000000..d218e98 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CommaInitializer.h @@ -0,0 +1,160 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_COMMAINITIALIZER_H +#define EIGEN_COMMAINITIALIZER_H + +namespace Eigen { + +/** \class CommaInitializer + * \ingroup Core_Module + * + * \brief Helper class used by the comma initializer operator + * + * This class is internally used to implement the comma initializer feature. It is + * the return type of MatrixBase::operator<<, and most of the time this is the only + * way it is used. + * + * \sa \blank \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished() + */ +template +struct CommaInitializer +{ + typedef typename XprType::Scalar Scalar; + + EIGEN_DEVICE_FUNC + inline CommaInitializer(XprType& xpr, const Scalar& s) + : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1) + { + m_xpr.coeffRef(0,0) = s; + } + + template + EIGEN_DEVICE_FUNC + inline CommaInitializer(XprType& xpr, const DenseBase& other) + : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows()) + { + m_xpr.block(0, 0, other.rows(), other.cols()) = other; + } + + /* Copy/Move constructor which transfers ownership. This is crucial in + * absence of return value optimization to avoid assertions during destruction. */ + // FIXME in C++11 mode this could be replaced by a proper RValue constructor + EIGEN_DEVICE_FUNC + inline CommaInitializer(const CommaInitializer& o) + : m_xpr(o.m_xpr), m_row(o.m_row), m_col(o.m_col), m_currentBlockRows(o.m_currentBlockRows) { + // Mark original object as finished. In absence of R-value references we need to const_cast: + const_cast(o).m_row = m_xpr.rows(); + const_cast(o).m_col = m_xpr.cols(); + const_cast(o).m_currentBlockRows = 0; + } + + /* inserts a scalar value in the target matrix */ + EIGEN_DEVICE_FUNC + CommaInitializer& operator,(const Scalar& s) + { + if (m_col==m_xpr.cols()) + { + m_row+=m_currentBlockRows; + m_col = 0; + m_currentBlockRows = 1; + eigen_assert(m_row + EIGEN_DEVICE_FUNC + CommaInitializer& operator,(const DenseBase& other) + { + if (m_col==m_xpr.cols() && (other.cols()!=0 || other.rows()!=m_currentBlockRows)) + { + m_row+=m_currentBlockRows; + m_col = 0; + m_currentBlockRows = other.rows(); + eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows() + && "Too many rows passed to comma initializer (operator<<)"); + } + eigen_assert((m_col + other.cols() <= m_xpr.cols()) + && "Too many coefficients passed to comma initializer (operator<<)"); + eigen_assert(m_currentBlockRows==other.rows()); + m_xpr.template block + (m_row, m_col, other.rows(), other.cols()) = other; + m_col += other.cols(); + return *this; + } + + EIGEN_DEVICE_FUNC + inline ~CommaInitializer() +#if defined VERIFY_RAISES_ASSERT && (!defined EIGEN_NO_ASSERTION_CHECKING) && defined EIGEN_EXCEPTIONS + EIGEN_EXCEPTION_SPEC(Eigen::eigen_assert_exception) +#endif + { + finished(); + } + + /** \returns the built matrix once all its coefficients have been set. + * Calling finished is 100% optional. Its purpose is to write expressions + * like this: + * \code + * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished()); + * \endcode + */ + EIGEN_DEVICE_FUNC + inline XprType& finished() { + eigen_assert(((m_row+m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0) + && m_col == m_xpr.cols() + && "Too few coefficients passed to comma initializer (operator<<)"); + return m_xpr; + } + + XprType& m_xpr; // target expression + Index m_row; // current row id + Index m_col; // current col id + Index m_currentBlockRows; // current block height +}; + +/** \anchor MatrixBaseCommaInitRef + * Convenient operator to set the coefficients of a matrix. + * + * The coefficients must be provided in a row major order and exactly match + * the size of the matrix. Otherwise an assertion is raised. + * + * Example: \include MatrixBase_set.cpp + * Output: \verbinclude MatrixBase_set.out + * + * \note According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary order. + * + * \sa CommaInitializer::finished(), class CommaInitializer + */ +template +inline CommaInitializer DenseBase::operator<< (const Scalar& s) +{ + return CommaInitializer(*static_cast(this), s); +} + +/** \sa operator<<(const Scalar&) */ +template +template +inline CommaInitializer +DenseBase::operator<<(const DenseBase& other) +{ + return CommaInitializer(*static_cast(this), other); +} + +} // end namespace Eigen + +#endif // EIGEN_COMMAINITIALIZER_H diff --git a/3rdparty/eigen3/Eigen/src/Core/ConditionEstimator.h b/3rdparty/eigen3/Eigen/src/Core/ConditionEstimator.h new file mode 100644 index 0000000..aa7efdc --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/ConditionEstimator.h @@ -0,0 +1,175 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2016 Rasmus Munk Larsen (rmlarsen@google.com) +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CONDITIONESTIMATOR_H +#define EIGEN_CONDITIONESTIMATOR_H + +namespace Eigen { + +namespace internal { + +template +struct rcond_compute_sign { + static inline Vector run(const Vector& v) { + const RealVector v_abs = v.cwiseAbs(); + return (v_abs.array() == static_cast(0)) + .select(Vector::Ones(v.size()), v.cwiseQuotient(v_abs)); + } +}; + +// Partial specialization to avoid elementwise division for real vectors. +template +struct rcond_compute_sign { + static inline Vector run(const Vector& v) { + return (v.array() < static_cast(0)) + .select(-Vector::Ones(v.size()), Vector::Ones(v.size())); + } +}; + +/** + * \returns an estimate of ||inv(matrix)||_1 given a decomposition of + * \a matrix that implements .solve() and .adjoint().solve() methods. + * + * This function implements Algorithms 4.1 and 5.1 from + * http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf + * which also forms the basis for the condition number estimators in + * LAPACK. Since at most 10 calls to the solve method of dec are + * performed, the total cost is O(dims^2), as opposed to O(dims^3) + * needed to compute the inverse matrix explicitly. + * + * The most common usage is in estimating the condition number + * ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be + * computed directly in O(n^2) operations. + * + * Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and + * LLT. + * + * \sa FullPivLU, PartialPivLU, LDLT, LLT. + */ +template +typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec) +{ + typedef typename Decomposition::MatrixType MatrixType; + typedef typename Decomposition::Scalar Scalar; + typedef typename Decomposition::RealScalar RealScalar; + typedef typename internal::plain_col_type::type Vector; + typedef typename internal::plain_col_type::type RealVector; + const bool is_complex = (NumTraits::IsComplex != 0); + + eigen_assert(dec.rows() == dec.cols()); + const Index n = dec.rows(); + if (n == 0) + return 0; + + // Disable Index to float conversion warning +#ifdef __INTEL_COMPILER + #pragma warning push + #pragma warning ( disable : 2259 ) +#endif + Vector v = dec.solve(Vector::Ones(n) / Scalar(n)); +#ifdef __INTEL_COMPILER + #pragma warning pop +#endif + + // lower_bound is a lower bound on + // ||inv(matrix)||_1 = sup_v ||inv(matrix) v||_1 / ||v||_1 + // and is the objective maximized by the ("super-") gradient ascent + // algorithm below. + RealScalar lower_bound = v.template lpNorm<1>(); + if (n == 1) + return lower_bound; + + // Gradient ascent algorithm follows: We know that the optimum is achieved at + // one of the simplices v = e_i, so in each iteration we follow a + // super-gradient to move towards the optimal one. + RealScalar old_lower_bound = lower_bound; + Vector sign_vector(n); + Vector old_sign_vector; + Index v_max_abs_index = -1; + Index old_v_max_abs_index = v_max_abs_index; + for (int k = 0; k < 4; ++k) + { + sign_vector = internal::rcond_compute_sign::run(v); + if (k > 0 && !is_complex && sign_vector == old_sign_vector) { + // Break if the solution stagnated. + break; + } + // v_max_abs_index = argmax |real( inv(matrix)^T * sign_vector )| + v = dec.adjoint().solve(sign_vector); + v.real().cwiseAbs().maxCoeff(&v_max_abs_index); + if (v_max_abs_index == old_v_max_abs_index) { + // Break if the solution stagnated. + break; + } + // Move to the new simplex e_j, where j = v_max_abs_index. + v = dec.solve(Vector::Unit(n, v_max_abs_index)); // v = inv(matrix) * e_j. + lower_bound = v.template lpNorm<1>(); + if (lower_bound <= old_lower_bound) { + // Break if the gradient step did not increase the lower_bound. + break; + } + if (!is_complex) { + old_sign_vector = sign_vector; + } + old_v_max_abs_index = v_max_abs_index; + old_lower_bound = lower_bound; + } + // The following calculates an independent estimate of ||matrix||_1 by + // multiplying matrix by a vector with entries of slowly increasing + // magnitude and alternating sign: + // v_i = (-1)^{i} (1 + (i / (dim-1))), i = 0,...,dim-1. + // This improvement to Hager's algorithm above is due to Higham. It was + // added to make the algorithm more robust in certain corner cases where + // large elements in the matrix might otherwise escape detection due to + // exact cancellation (especially when op and op_adjoint correspond to a + // sequence of backsubstitutions and permutations), which could cause + // Hager's algorithm to vastly underestimate ||matrix||_1. + Scalar alternating_sign(RealScalar(1)); + for (Index i = 0; i < n; ++i) { + // The static_cast is needed when Scalar is a complex and RealScalar implements expression templates + v[i] = alternating_sign * static_cast(RealScalar(1) + (RealScalar(i) / (RealScalar(n - 1)))); + alternating_sign = -alternating_sign; + } + v = dec.solve(v); + const RealScalar alternate_lower_bound = (2 * v.template lpNorm<1>()) / (3 * RealScalar(n)); + return numext::maxi(lower_bound, alternate_lower_bound); +} + +/** \brief Reciprocal condition number estimator. + * + * Computing a decomposition of a dense matrix takes O(n^3) operations, while + * this method estimates the condition number quickly and reliably in O(n^2) + * operations. + * + * \returns an estimate of the reciprocal condition number + * (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and + * its decomposition. Supports the following decompositions: FullPivLU, + * PartialPivLU, LDLT, and LLT. + * + * \sa FullPivLU, PartialPivLU, LDLT, LLT. + */ +template +typename Decomposition::RealScalar +rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm, const Decomposition& dec) +{ + typedef typename Decomposition::RealScalar RealScalar; + eigen_assert(dec.rows() == dec.cols()); + if (dec.rows() == 0) return RealScalar(1); + if (matrix_norm == RealScalar(0)) return RealScalar(0); + if (dec.rows() == 1) return RealScalar(1); + const RealScalar inverse_matrix_norm = rcond_invmatrix_L1_norm_estimate(dec); + return (inverse_matrix_norm == RealScalar(0) ? RealScalar(0) + : (RealScalar(1) / inverse_matrix_norm) / matrix_norm); +} + +} // namespace internal + +} // namespace Eigen + +#endif diff --git a/3rdparty/eigen3/Eigen/src/Core/CoreEvaluators.h b/3rdparty/eigen3/Eigen/src/Core/CoreEvaluators.h new file mode 100644 index 0000000..910889e --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CoreEvaluators.h @@ -0,0 +1,1688 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2011 Benoit Jacob +// Copyright (C) 2011-2014 Gael Guennebaud +// Copyright (C) 2011-2012 Jitse Niesen +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + + +#ifndef EIGEN_COREEVALUATORS_H +#define EIGEN_COREEVALUATORS_H + +namespace Eigen { + +namespace internal { + +// This class returns the evaluator kind from the expression storage kind. +// Default assumes index based accessors +template +struct storage_kind_to_evaluator_kind { + typedef IndexBased Kind; +}; + +// This class returns the evaluator shape from the expression storage kind. +// It can be Dense, Sparse, Triangular, Diagonal, SelfAdjoint, Band, etc. +template struct storage_kind_to_shape; + +template<> struct storage_kind_to_shape { typedef DenseShape Shape; }; +template<> struct storage_kind_to_shape { typedef SolverShape Shape; }; +template<> struct storage_kind_to_shape { typedef PermutationShape Shape; }; +template<> struct storage_kind_to_shape { typedef TranspositionsShape Shape; }; + +// Evaluators have to be specialized with respect to various criteria such as: +// - storage/structure/shape +// - scalar type +// - etc. +// Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators. +// We currently distinguish the following kind of evaluators: +// - unary_evaluator for expressions taking only one arguments (CwiseUnaryOp, CwiseUnaryView, Transpose, MatrixWrapper, ArrayWrapper, Reverse, Replicate) +// - binary_evaluator for expression taking two arguments (CwiseBinaryOp) +// - ternary_evaluator for expression taking three arguments (CwiseTernaryOp) +// - product_evaluator for linear algebra products (Product); special case of binary_evaluator because it requires additional tags for dispatching. +// - mapbase_evaluator for Map, Block, Ref +// - block_evaluator for Block (special dispatching to a mapbase_evaluator or unary_evaluator) + +template< typename T, + typename Arg1Kind = typename evaluator_traits::Kind, + typename Arg2Kind = typename evaluator_traits::Kind, + typename Arg3Kind = typename evaluator_traits::Kind, + typename Arg1Scalar = typename traits::Scalar, + typename Arg2Scalar = typename traits::Scalar, + typename Arg3Scalar = typename traits::Scalar> struct ternary_evaluator; + +template< typename T, + typename LhsKind = typename evaluator_traits::Kind, + typename RhsKind = typename evaluator_traits::Kind, + typename LhsScalar = typename traits::Scalar, + typename RhsScalar = typename traits::Scalar> struct binary_evaluator; + +template< typename T, + typename Kind = typename evaluator_traits::Kind, + typename Scalar = typename T::Scalar> struct unary_evaluator; + +// evaluator_traits contains traits for evaluator + +template +struct evaluator_traits_base +{ + // by default, get evaluator kind and shape from storage + typedef typename storage_kind_to_evaluator_kind::StorageKind>::Kind Kind; + typedef typename storage_kind_to_shape::StorageKind>::Shape Shape; +}; + +// Default evaluator traits +template +struct evaluator_traits : public evaluator_traits_base +{ +}; + +template::Shape > +struct evaluator_assume_aliasing { + static const bool value = false; +}; + +// By default, we assume a unary expression: +template +struct evaluator : public unary_evaluator +{ + typedef unary_evaluator Base; + EIGEN_DEVICE_FUNC explicit evaluator(const T& xpr) : Base(xpr) {} +}; + + +// TODO: Think about const-correctness +template +struct evaluator + : evaluator +{ + EIGEN_DEVICE_FUNC + explicit evaluator(const T& xpr) : evaluator(xpr) {} +}; + +// ---------- base class for all evaluators ---------- + +template +struct evaluator_base : public noncopyable +{ + // TODO that's not very nice to have to propagate all these traits. They are currently only needed to handle outer,inner indices. + typedef traits ExpressionTraits; + + enum { + Alignment = 0 + }; +}; + +// -------------------- Matrix and Array -------------------- +// +// evaluator is a common base class for the +// Matrix and Array evaluators. +// Here we directly specialize evaluator. This is not really a unary expression, and it is, by definition, dense, +// so no need for more sophisticated dispatching. + +template +struct evaluator > + : evaluator_base +{ + typedef PlainObjectBase PlainObjectType; + typedef typename PlainObjectType::Scalar Scalar; + typedef typename PlainObjectType::CoeffReturnType CoeffReturnType; + + enum { + IsRowMajor = PlainObjectType::IsRowMajor, + IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime, + RowsAtCompileTime = PlainObjectType::RowsAtCompileTime, + ColsAtCompileTime = PlainObjectType::ColsAtCompileTime, + + CoeffReadCost = NumTraits::ReadCost, + Flags = traits::EvaluatorFlags, + Alignment = traits::Alignment + }; + + EIGEN_DEVICE_FUNC evaluator() + : m_data(0), + m_outerStride(IsVectorAtCompileTime ? 0 + : int(IsRowMajor) ? ColsAtCompileTime + : RowsAtCompileTime) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + EIGEN_DEVICE_FUNC explicit evaluator(const PlainObjectType& m) + : m_data(m.data()), m_outerStride(IsVectorAtCompileTime ? 0 : m.outerStride()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + if (IsRowMajor) + return m_data[row * m_outerStride.value() + col]; + else + return m_data[row + col * m_outerStride.value()]; + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_data[index]; + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index col) + { + if (IsRowMajor) + return const_cast(m_data)[row * m_outerStride.value() + col]; + else + return const_cast(m_data)[row + col * m_outerStride.value()]; + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index index) + { + return const_cast(m_data)[index]; + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + if (IsRowMajor) + return ploadt(m_data + row * m_outerStride.value() + col); + else + return ploadt(m_data + row + col * m_outerStride.value()); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + return ploadt(m_data + index); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index row, Index col, const PacketType& x) + { + if (IsRowMajor) + return pstoret + (const_cast(m_data) + row * m_outerStride.value() + col, x); + else + return pstoret + (const_cast(m_data) + row + col * m_outerStride.value(), x); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index index, const PacketType& x) + { + return pstoret(const_cast(m_data) + index, x); + } + +protected: + const Scalar *m_data; + + // We do not need to know the outer stride for vectors + variable_if_dynamic m_outerStride; +}; + +template +struct evaluator > + : evaluator > > +{ + typedef Matrix XprType; + + EIGEN_DEVICE_FUNC evaluator() {} + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m) + : evaluator >(m) + { } +}; + +template +struct evaluator > + : evaluator > > +{ + typedef Array XprType; + + EIGEN_DEVICE_FUNC evaluator() {} + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m) + : evaluator >(m) + { } +}; + +// -------------------- Transpose -------------------- + +template +struct unary_evaluator, IndexBased> + : evaluator_base > +{ + typedef Transpose XprType; + + enum { + CoeffReadCost = evaluator::CoeffReadCost, + Flags = evaluator::Flags ^ RowMajorBit, + Alignment = evaluator::Alignment + }; + + EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpression()) {} + + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_argImpl.coeff(col, row); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_argImpl.coeff(index); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index col) + { + return m_argImpl.coeffRef(col, row); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + typename XprType::Scalar& coeffRef(Index index) + { + return m_argImpl.coeffRef(index); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + return m_argImpl.template packet(col, row); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + return m_argImpl.template packet(index); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index row, Index col, const PacketType& x) + { + m_argImpl.template writePacket(col, row, x); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index index, const PacketType& x) + { + m_argImpl.template writePacket(index, x); + } + +protected: + evaluator m_argImpl; +}; + +// -------------------- CwiseNullaryOp -------------------- +// Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator. +// Likewise, there is not need to more sophisticated dispatching here. + +template::value, + bool has_unary = has_unary_operator::value, + bool has_binary = has_binary_operator::value> +struct nullary_wrapper +{ + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const { return op(i,j); } + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); } + + template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const { return op.template packetOp(i,j); } + template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp(i); } +}; + +template +struct nullary_wrapper +{ + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType=0, IndexType=0) const { return op(); } + template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType=0, IndexType=0) const { return op.template packetOp(); } +}; + +template +struct nullary_wrapper +{ + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j=0) const { return op(i,j); } + template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j=0) const { return op.template packetOp(i,j); } +}; + +// We need the following specialization for vector-only functors assigned to a runtime vector, +// for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd. +// In this case, i==0 and j is used for the actual iteration. +template +struct nullary_wrapper +{ + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const { + eigen_assert(i==0 || j==0); + return op(i+j); + } + template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const { + eigen_assert(i==0 || j==0); + return op.template packetOp(i+j); + } + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); } + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp(i); } +}; + +template +struct nullary_wrapper {}; + +#if 0 && EIGEN_COMP_MSVC>0 +// Disable this ugly workaround. This is now handled in traits::match, +// but this piece of code might still become handly if some other weird compilation +// erros pop up again. + +// MSVC exhibits a weird compilation error when +// compiling: +// Eigen::MatrixXf A = MatrixXf::Random(3,3); +// Ref R = 2.f*A; +// and that has_*ary_operator> have not been instantiated yet. +// The "problem" is that evaluator<2.f*A> is instantiated by traits::match<2.f*A> +// and at that time has_*ary_operator returns true regardless of T. +// Then nullary_wrapper is badly instantiated as nullary_wrapper<.,.,true,true,true>. +// The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(), +// and packet() are really instantiated as implemented below: + +// This is a simple wrapper around Index to enforce the re-instantiation of +// has_*ary_operator when needed. +template struct nullary_wrapper_workaround_msvc { + nullary_wrapper_workaround_msvc(const T&); + operator T()const; +}; + +template +struct nullary_wrapper +{ + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const { + return nullary_wrapper >::value, + has_unary_operator >::value, + has_binary_operator >::value>().operator()(op,i,j); + } + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { + return nullary_wrapper >::value, + has_unary_operator >::value, + has_binary_operator >::value>().operator()(op,i); + } + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const { + return nullary_wrapper >::value, + has_unary_operator >::value, + has_binary_operator >::value>().template packetOp(op,i,j); + } + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { + return nullary_wrapper >::value, + has_unary_operator >::value, + has_binary_operator >::value>().template packetOp(op,i); + } +}; +#endif // MSVC workaround + +template +struct evaluator > + : evaluator_base > +{ + typedef CwiseNullaryOp XprType; + typedef typename internal::remove_all::type PlainObjectTypeCleaned; + + enum { + CoeffReadCost = internal::functor_traits::Cost, + + Flags = (evaluator::Flags + & ( HereditaryBits + | (functor_has_linear_access::ret ? LinearAccessBit : 0) + | (functor_traits::PacketAccess ? PacketAccessBit : 0))) + | (functor_traits::IsRepeatable ? 0 : EvalBeforeNestingBit), + Alignment = AlignedMax + }; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n) + : m_functor(n.functor()), m_wrapper() + { + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + typedef typename XprType::CoeffReturnType CoeffReturnType; + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(IndexType row, IndexType col) const + { + return m_wrapper(m_functor, row, col); + } + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(IndexType index) const + { + return m_wrapper(m_functor,index); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(IndexType row, IndexType col) const + { + return m_wrapper.template packetOp(m_functor, row, col); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(IndexType index) const + { + return m_wrapper.template packetOp(m_functor, index); + } + +protected: + const NullaryOp m_functor; + const internal::nullary_wrapper m_wrapper; +}; + +// -------------------- CwiseUnaryOp -------------------- + +template +struct unary_evaluator, IndexBased > + : evaluator_base > +{ + typedef CwiseUnaryOp XprType; + + enum { + CoeffReadCost = evaluator::CoeffReadCost + functor_traits::Cost, + + Flags = evaluator::Flags + & (HereditaryBits | LinearAccessBit | (functor_traits::PacketAccess ? PacketAccessBit : 0)), + Alignment = evaluator::Alignment + }; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + explicit unary_evaluator(const XprType& op) + : m_functor(op.functor()), + m_argImpl(op.nestedExpression()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits::Cost); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_functor(m_argImpl.coeff(row, col)); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_functor(m_argImpl.coeff(index)); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + return m_functor.packetOp(m_argImpl.template packet(row, col)); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + return m_functor.packetOp(m_argImpl.template packet(index)); + } + +protected: + const UnaryOp m_functor; + evaluator m_argImpl; +}; + +// -------------------- CwiseTernaryOp -------------------- + +// this is a ternary expression +template +struct evaluator > + : public ternary_evaluator > +{ + typedef CwiseTernaryOp XprType; + typedef ternary_evaluator > Base; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {} +}; + +template +struct ternary_evaluator, IndexBased, IndexBased> + : evaluator_base > +{ + typedef CwiseTernaryOp XprType; + + enum { + CoeffReadCost = evaluator::CoeffReadCost + evaluator::CoeffReadCost + evaluator::CoeffReadCost + functor_traits::Cost, + + Arg1Flags = evaluator::Flags, + Arg2Flags = evaluator::Flags, + Arg3Flags = evaluator::Flags, + SameType = is_same::value && is_same::value, + StorageOrdersAgree = (int(Arg1Flags)&RowMajorBit)==(int(Arg2Flags)&RowMajorBit) && (int(Arg1Flags)&RowMajorBit)==(int(Arg3Flags)&RowMajorBit), + Flags0 = (int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) & ( + HereditaryBits + | (int(Arg1Flags) & int(Arg2Flags) & int(Arg3Flags) & + ( (StorageOrdersAgree ? LinearAccessBit : 0) + | (functor_traits::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0) + ) + ) + ), + Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags & RowMajorBit), + Alignment = EIGEN_PLAIN_ENUM_MIN( + EIGEN_PLAIN_ENUM_MIN(evaluator::Alignment, evaluator::Alignment), + evaluator::Alignment) + }; + + EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr) + : m_functor(xpr.functor()), + m_arg1Impl(xpr.arg1()), + m_arg2Impl(xpr.arg2()), + m_arg3Impl(xpr.arg3()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits::Cost); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_functor(m_arg1Impl.coeff(row, col), m_arg2Impl.coeff(row, col), m_arg3Impl.coeff(row, col)); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_functor(m_arg1Impl.coeff(index), m_arg2Impl.coeff(index), m_arg3Impl.coeff(index)); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + return m_functor.packetOp(m_arg1Impl.template packet(row, col), + m_arg2Impl.template packet(row, col), + m_arg3Impl.template packet(row, col)); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + return m_functor.packetOp(m_arg1Impl.template packet(index), + m_arg2Impl.template packet(index), + m_arg3Impl.template packet(index)); + } + +protected: + const TernaryOp m_functor; + evaluator m_arg1Impl; + evaluator m_arg2Impl; + evaluator m_arg3Impl; +}; + +// -------------------- CwiseBinaryOp -------------------- + +// this is a binary expression +template +struct evaluator > + : public binary_evaluator > +{ + typedef CwiseBinaryOp XprType; + typedef binary_evaluator > Base; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {} +}; + +template +struct binary_evaluator, IndexBased, IndexBased> + : evaluator_base > +{ + typedef CwiseBinaryOp XprType; + + enum { + CoeffReadCost = evaluator::CoeffReadCost + evaluator::CoeffReadCost + functor_traits::Cost, + + LhsFlags = evaluator::Flags, + RhsFlags = evaluator::Flags, + SameType = is_same::value, + StorageOrdersAgree = (int(LhsFlags)&RowMajorBit)==(int(RhsFlags)&RowMajorBit), + Flags0 = (int(LhsFlags) | int(RhsFlags)) & ( + HereditaryBits + | (int(LhsFlags) & int(RhsFlags) & + ( (StorageOrdersAgree ? LinearAccessBit : 0) + | (functor_traits::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0) + ) + ) + ), + Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit), + Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator::Alignment,evaluator::Alignment) + }; + + EIGEN_DEVICE_FUNC explicit binary_evaluator(const XprType& xpr) + : m_functor(xpr.functor()), + m_lhsImpl(xpr.lhs()), + m_rhsImpl(xpr.rhs()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits::Cost); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_functor(m_lhsImpl.coeff(row, col), m_rhsImpl.coeff(row, col)); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_functor(m_lhsImpl.coeff(index), m_rhsImpl.coeff(index)); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + return m_functor.packetOp(m_lhsImpl.template packet(row, col), + m_rhsImpl.template packet(row, col)); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + return m_functor.packetOp(m_lhsImpl.template packet(index), + m_rhsImpl.template packet(index)); + } + +protected: + const BinaryOp m_functor; + evaluator m_lhsImpl; + evaluator m_rhsImpl; +}; + +// -------------------- CwiseUnaryView -------------------- + +template +struct unary_evaluator, IndexBased> + : evaluator_base > +{ + typedef CwiseUnaryView XprType; + + enum { + CoeffReadCost = evaluator::CoeffReadCost + functor_traits::Cost, + + Flags = (evaluator::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit)), + + Alignment = 0 // FIXME it is not very clear why alignment is necessarily lost... + }; + + EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) + : m_unaryOp(op.functor()), + m_argImpl(op.nestedExpression()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits::Cost); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_unaryOp(m_argImpl.coeff(row, col)); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_unaryOp(m_argImpl.coeff(index)); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index col) + { + return m_unaryOp(m_argImpl.coeffRef(row, col)); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index index) + { + return m_unaryOp(m_argImpl.coeffRef(index)); + } + +protected: + const UnaryOp m_unaryOp; + evaluator m_argImpl; +}; + +// -------------------- Map -------------------- + +// FIXME perhaps the PlainObjectType could be provided by Derived::PlainObject ? +// but that might complicate template specialization +template +struct mapbase_evaluator; + +template +struct mapbase_evaluator : evaluator_base +{ + typedef Derived XprType; + typedef typename XprType::PointerType PointerType; + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + + enum { + IsRowMajor = XprType::RowsAtCompileTime, + ColsAtCompileTime = XprType::ColsAtCompileTime, + CoeffReadCost = NumTraits::ReadCost + }; + + EIGEN_DEVICE_FUNC explicit mapbase_evaluator(const XprType& map) + : m_data(const_cast(map.data())), + m_innerStride(map.innerStride()), + m_outerStride(map.outerStride()) + { + EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator::Flags&PacketAccessBit, internal::inner_stride_at_compile_time::ret==1), + PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_data[col * colStride() + row * rowStride()]; + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_data[index * m_innerStride.value()]; + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index col) + { + return m_data[col * colStride() + row * rowStride()]; + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index index) + { + return m_data[index * m_innerStride.value()]; + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + PointerType ptr = m_data + row * rowStride() + col * colStride(); + return internal::ploadt(ptr); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + return internal::ploadt(m_data + index * m_innerStride.value()); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index row, Index col, const PacketType& x) + { + PointerType ptr = m_data + row * rowStride() + col * colStride(); + return internal::pstoret(ptr, x); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index index, const PacketType& x) + { + internal::pstoret(m_data + index * m_innerStride.value(), x); + } +protected: + EIGEN_DEVICE_FUNC + inline Index rowStride() const { return XprType::IsRowMajor ? m_outerStride.value() : m_innerStride.value(); } + EIGEN_DEVICE_FUNC + inline Index colStride() const { return XprType::IsRowMajor ? m_innerStride.value() : m_outerStride.value(); } + + PointerType m_data; + const internal::variable_if_dynamic m_innerStride; + const internal::variable_if_dynamic m_outerStride; +}; + +template +struct evaluator > + : public mapbase_evaluator, PlainObjectType> +{ + typedef Map XprType; + typedef typename XprType::Scalar Scalar; + // TODO: should check for smaller packet types once we can handle multi-sized packet types + typedef typename packet_traits::type PacketScalar; + + enum { + InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0 + ? int(PlainObjectType::InnerStrideAtCompileTime) + : int(StrideType::InnerStrideAtCompileTime), + OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0 + ? int(PlainObjectType::OuterStrideAtCompileTime) + : int(StrideType::OuterStrideAtCompileTime), + HasNoInnerStride = InnerStrideAtCompileTime == 1, + HasNoOuterStride = StrideType::OuterStrideAtCompileTime == 0, + HasNoStride = HasNoInnerStride && HasNoOuterStride, + IsDynamicSize = PlainObjectType::SizeAtCompileTime==Dynamic, + + PacketAccessMask = bool(HasNoInnerStride) ? ~int(0) : ~int(PacketAccessBit), + LinearAccessMask = bool(HasNoStride) || bool(PlainObjectType::IsVectorAtCompileTime) ? ~int(0) : ~int(LinearAccessBit), + Flags = int( evaluator::Flags) & (LinearAccessMask&PacketAccessMask), + + Alignment = int(MapOptions)&int(AlignedMask) + }; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map) + : mapbase_evaluator(map) + { } +}; + +// -------------------- Ref -------------------- + +template +struct evaluator > + : public mapbase_evaluator, PlainObjectType> +{ + typedef Ref XprType; + + enum { + Flags = evaluator >::Flags, + Alignment = evaluator >::Alignment + }; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& ref) + : mapbase_evaluator(ref) + { } +}; + +// -------------------- Block -------------------- + +template::ret> struct block_evaluator; + +template +struct evaluator > + : block_evaluator +{ + typedef Block XprType; + typedef typename XprType::Scalar Scalar; + // TODO: should check for smaller packet types once we can handle multi-sized packet types + typedef typename packet_traits::type PacketScalar; + + enum { + CoeffReadCost = evaluator::CoeffReadCost, + + RowsAtCompileTime = traits::RowsAtCompileTime, + ColsAtCompileTime = traits::ColsAtCompileTime, + MaxRowsAtCompileTime = traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = traits::MaxColsAtCompileTime, + + ArgTypeIsRowMajor = (int(evaluator::Flags)&RowMajorBit) != 0, + IsRowMajor = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? 1 + : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0 + : ArgTypeIsRowMajor, + HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajor), + InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime), + InnerStrideAtCompileTime = HasSameStorageOrderAsArgType + ? int(inner_stride_at_compile_time::ret) + : int(outer_stride_at_compile_time::ret), + OuterStrideAtCompileTime = HasSameStorageOrderAsArgType + ? int(outer_stride_at_compile_time::ret) + : int(inner_stride_at_compile_time::ret), + MaskPacketAccessBit = (InnerStrideAtCompileTime == 1 || HasSameStorageOrderAsArgType) ? PacketAccessBit : 0, + + FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1 || (InnerPanel && (evaluator::Flags&LinearAccessBit))) ? LinearAccessBit : 0, + FlagsRowMajorBit = XprType::Flags&RowMajorBit, + Flags0 = evaluator::Flags & ( (HereditaryBits & ~RowMajorBit) | + DirectAccessBit | + MaskPacketAccessBit), + Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit, + + PacketAlignment = unpacket_traits::alignment, + Alignment0 = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) + && (OuterStrideAtCompileTime!=0) + && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % int(PacketAlignment)) == 0)) ? int(PacketAlignment) : 0, + Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator::Alignment, Alignment0) + }; + typedef block_evaluator block_evaluator_type; + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& block) : block_evaluator_type(block) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } +}; + +// no direct-access => dispatch to a unary evaluator +template +struct block_evaluator + : unary_evaluator > +{ + typedef Block XprType; + + EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block) + : unary_evaluator(block) + {} +}; + +template +struct unary_evaluator, IndexBased> + : evaluator_base > +{ + typedef Block XprType; + + EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& block) + : m_argImpl(block.nestedExpression()), + m_startRow(block.startRow()), + m_startCol(block.startCol()), + m_linear_offset(InnerPanel?(XprType::IsRowMajor ? block.startRow()*block.cols() : block.startCol()*block.rows()):0) + { } + + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + + enum { + RowsAtCompileTime = XprType::RowsAtCompileTime, + ForwardLinearAccess = InnerPanel && bool(evaluator::Flags&LinearAccessBit) + }; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_argImpl.coeff(m_startRow.value() + row, m_startCol.value() + col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + if (ForwardLinearAccess) + return m_argImpl.coeff(m_linear_offset.value() + index); + else + return coeff(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index col) + { + return m_argImpl.coeffRef(m_startRow.value() + row, m_startCol.value() + col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index index) + { + if (ForwardLinearAccess) + return m_argImpl.coeffRef(m_linear_offset.value() + index); + else + return coeffRef(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + return m_argImpl.template packet(m_startRow.value() + row, m_startCol.value() + col); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + if (ForwardLinearAccess) + return m_argImpl.template packet(m_linear_offset.value() + index); + else + return packet(RowsAtCompileTime == 1 ? 0 : index, + RowsAtCompileTime == 1 ? index : 0); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index row, Index col, const PacketType& x) + { + return m_argImpl.template writePacket(m_startRow.value() + row, m_startCol.value() + col, x); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index index, const PacketType& x) + { + if (ForwardLinearAccess) + return m_argImpl.template writePacket(m_linear_offset.value() + index, x); + else + return writePacket(RowsAtCompileTime == 1 ? 0 : index, + RowsAtCompileTime == 1 ? index : 0, + x); + } + +protected: + evaluator m_argImpl; + const variable_if_dynamic m_startRow; + const variable_if_dynamic m_startCol; + const variable_if_dynamic m_linear_offset; +}; + +// TODO: This evaluator does not actually use the child evaluator; +// all action is via the data() as returned by the Block expression. + +template +struct block_evaluator + : mapbase_evaluator, + typename Block::PlainObject> +{ + typedef Block XprType; + typedef typename XprType::Scalar Scalar; + + EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block) + : mapbase_evaluator(block) + { + // TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime + eigen_assert(((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator::Alignment)) == 0) && "data is not aligned"); + } +}; + + +// -------------------- Select -------------------- +// NOTE shall we introduce a ternary_evaluator? + +// TODO enable vectorization for Select +template +struct evaluator > + : evaluator_base > +{ + typedef Select XprType; + enum { + CoeffReadCost = evaluator::CoeffReadCost + + EIGEN_PLAIN_ENUM_MAX(evaluator::CoeffReadCost, + evaluator::CoeffReadCost), + + Flags = (unsigned int)evaluator::Flags & evaluator::Flags & HereditaryBits, + + Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator::Alignment, evaluator::Alignment) + }; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& select) + : m_conditionImpl(select.conditionMatrix()), + m_thenImpl(select.thenMatrix()), + m_elseImpl(select.elseMatrix()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + if (m_conditionImpl.coeff(row, col)) + return m_thenImpl.coeff(row, col); + else + return m_elseImpl.coeff(row, col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + if (m_conditionImpl.coeff(index)) + return m_thenImpl.coeff(index); + else + return m_elseImpl.coeff(index); + } + +protected: + evaluator m_conditionImpl; + evaluator m_thenImpl; + evaluator m_elseImpl; +}; + + +// -------------------- Replicate -------------------- + +template +struct unary_evaluator > + : evaluator_base > +{ + typedef Replicate XprType; + typedef typename XprType::CoeffReturnType CoeffReturnType; + enum { + Factor = (RowFactor==Dynamic || ColFactor==Dynamic) ? Dynamic : RowFactor*ColFactor + }; + typedef typename internal::nested_eval::type ArgTypeNested; + typedef typename internal::remove_all::type ArgTypeNestedCleaned; + + enum { + CoeffReadCost = evaluator::CoeffReadCost, + LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0, + Flags = (evaluator::Flags & (HereditaryBits|LinearAccessMask) & ~RowMajorBit) | (traits::Flags & RowMajorBit), + + Alignment = evaluator::Alignment + }; + + EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& replicate) + : m_arg(replicate.nestedExpression()), + m_argImpl(m_arg), + m_rows(replicate.nestedExpression().rows()), + m_cols(replicate.nestedExpression().cols()) + {} + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + // try to avoid using modulo; this is a pure optimization strategy + const Index actual_row = internal::traits::RowsAtCompileTime==1 ? 0 + : RowFactor==1 ? row + : row % m_rows.value(); + const Index actual_col = internal::traits::ColsAtCompileTime==1 ? 0 + : ColFactor==1 ? col + : col % m_cols.value(); + + return m_argImpl.coeff(actual_row, actual_col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + // try to avoid using modulo; this is a pure optimization strategy + const Index actual_index = internal::traits::RowsAtCompileTime==1 + ? (ColFactor==1 ? index : index%m_cols.value()) + : (RowFactor==1 ? index : index%m_rows.value()); + + return m_argImpl.coeff(actual_index); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + const Index actual_row = internal::traits::RowsAtCompileTime==1 ? 0 + : RowFactor==1 ? row + : row % m_rows.value(); + const Index actual_col = internal::traits::ColsAtCompileTime==1 ? 0 + : ColFactor==1 ? col + : col % m_cols.value(); + + return m_argImpl.template packet(actual_row, actual_col); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + const Index actual_index = internal::traits::RowsAtCompileTime==1 + ? (ColFactor==1 ? index : index%m_cols.value()) + : (RowFactor==1 ? index : index%m_rows.value()); + + return m_argImpl.template packet(actual_index); + } + +protected: + const ArgTypeNested m_arg; + evaluator m_argImpl; + const variable_if_dynamic m_rows; + const variable_if_dynamic m_cols; +}; + + +// -------------------- PartialReduxExpr -------------------- + +template< typename ArgType, typename MemberOp, int Direction> +struct evaluator > + : evaluator_base > +{ + typedef PartialReduxExpr XprType; + typedef typename internal::nested_eval::type ArgTypeNested; + typedef typename internal::remove_all::type ArgTypeNestedCleaned; + typedef typename ArgType::Scalar InputScalar; + typedef typename XprType::Scalar Scalar; + enum { + TraversalSize = Direction==int(Vertical) ? int(ArgType::RowsAtCompileTime) : int(ArgType::ColsAtCompileTime) + }; + typedef typename MemberOp::template Cost CostOpType; + enum { + CoeffReadCost = TraversalSize==Dynamic ? HugeCost + : TraversalSize * evaluator::CoeffReadCost + int(CostOpType::value), + + Flags = (traits::Flags&RowMajorBit) | (evaluator::Flags&(HereditaryBits&(~RowMajorBit))) | LinearAccessBit, + + Alignment = 0 // FIXME this will need to be improved once PartialReduxExpr is vectorized + }; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr) + : m_arg(xpr.nestedExpression()), m_functor(xpr.functor()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(TraversalSize==Dynamic ? HugeCost : int(CostOpType::value)); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + const Scalar coeff(Index i, Index j) const + { + if (Direction==Vertical) + return m_functor(m_arg.col(j)); + else + return m_functor(m_arg.row(i)); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + const Scalar coeff(Index index) const + { + if (Direction==Vertical) + return m_functor(m_arg.col(index)); + else + return m_functor(m_arg.row(index)); + } + +protected: + typename internal::add_const_on_value_type::type m_arg; + const MemberOp m_functor; +}; + + +// -------------------- MatrixWrapper and ArrayWrapper -------------------- +// +// evaluator_wrapper_base is a common base class for the +// MatrixWrapper and ArrayWrapper evaluators. + +template +struct evaluator_wrapper_base + : evaluator_base +{ + typedef typename remove_all::type ArgType; + enum { + CoeffReadCost = evaluator::CoeffReadCost, + Flags = evaluator::Flags, + Alignment = evaluator::Alignment + }; + + EIGEN_DEVICE_FUNC explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {} + + typedef typename ArgType::Scalar Scalar; + typedef typename ArgType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_argImpl.coeff(row, col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_argImpl.coeff(index); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index col) + { + return m_argImpl.coeffRef(row, col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index index) + { + return m_argImpl.coeffRef(index); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + return m_argImpl.template packet(row, col); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + return m_argImpl.template packet(index); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index row, Index col, const PacketType& x) + { + m_argImpl.template writePacket(row, col, x); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index index, const PacketType& x) + { + m_argImpl.template writePacket(index, x); + } + +protected: + evaluator m_argImpl; +}; + +template +struct unary_evaluator > + : evaluator_wrapper_base > +{ + typedef MatrixWrapper XprType; + + EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper) + : evaluator_wrapper_base >(wrapper.nestedExpression()) + { } +}; + +template +struct unary_evaluator > + : evaluator_wrapper_base > +{ + typedef ArrayWrapper XprType; + + EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper) + : evaluator_wrapper_base >(wrapper.nestedExpression()) + { } +}; + + +// -------------------- Reverse -------------------- + +// defined in Reverse.h: +template struct reverse_packet_cond; + +template +struct unary_evaluator > + : evaluator_base > +{ + typedef Reverse XprType; + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + + enum { + IsRowMajor = XprType::IsRowMajor, + IsColMajor = !IsRowMajor, + ReverseRow = (Direction == Vertical) || (Direction == BothDirections), + ReverseCol = (Direction == Horizontal) || (Direction == BothDirections), + ReversePacket = (Direction == BothDirections) + || ((Direction == Vertical) && IsColMajor) + || ((Direction == Horizontal) && IsRowMajor), + + CoeffReadCost = evaluator::CoeffReadCost, + + // let's enable LinearAccess only with vectorization because of the product overhead + // FIXME enable DirectAccess with negative strides? + Flags0 = evaluator::Flags, + LinearAccess = ( (Direction==BothDirections) && (int(Flags0)&PacketAccessBit) ) + || ((ReverseRow && XprType::ColsAtCompileTime==1) || (ReverseCol && XprType::RowsAtCompileTime==1)) + ? LinearAccessBit : 0, + + Flags = int(Flags0) & (HereditaryBits | PacketAccessBit | LinearAccess), + + Alignment = 0 // FIXME in some rare cases, Alignment could be preserved, like a Vector4f. + }; + + EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& reverse) + : m_argImpl(reverse.nestedExpression()), + m_rows(ReverseRow ? reverse.nestedExpression().rows() : 1), + m_cols(ReverseCol ? reverse.nestedExpression().cols() : 1) + { } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index col) const + { + return m_argImpl.coeff(ReverseRow ? m_rows.value() - row - 1 : row, + ReverseCol ? m_cols.value() - col - 1 : col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_argImpl.coeff(m_rows.value() * m_cols.value() - index - 1); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index col) + { + return m_argImpl.coeffRef(ReverseRow ? m_rows.value() - row - 1 : row, + ReverseCol ? m_cols.value() - col - 1 : col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index index) + { + return m_argImpl.coeffRef(m_rows.value() * m_cols.value() - index - 1); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index row, Index col) const + { + enum { + PacketSize = unpacket_traits::size, + OffsetRow = ReverseRow && IsColMajor ? PacketSize : 1, + OffsetCol = ReverseCol && IsRowMajor ? PacketSize : 1 + }; + typedef internal::reverse_packet_cond reverse_packet; + return reverse_packet::run(m_argImpl.template packet( + ReverseRow ? m_rows.value() - row - OffsetRow : row, + ReverseCol ? m_cols.value() - col - OffsetCol : col)); + } + + template + EIGEN_STRONG_INLINE + PacketType packet(Index index) const + { + enum { PacketSize = unpacket_traits::size }; + return preverse(m_argImpl.template packet(m_rows.value() * m_cols.value() - index - PacketSize)); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index row, Index col, const PacketType& x) + { + // FIXME we could factorize some code with packet(i,j) + enum { + PacketSize = unpacket_traits::size, + OffsetRow = ReverseRow && IsColMajor ? PacketSize : 1, + OffsetCol = ReverseCol && IsRowMajor ? PacketSize : 1 + }; + typedef internal::reverse_packet_cond reverse_packet; + m_argImpl.template writePacket( + ReverseRow ? m_rows.value() - row - OffsetRow : row, + ReverseCol ? m_cols.value() - col - OffsetCol : col, + reverse_packet::run(x)); + } + + template + EIGEN_STRONG_INLINE + void writePacket(Index index, const PacketType& x) + { + enum { PacketSize = unpacket_traits::size }; + m_argImpl.template writePacket + (m_rows.value() * m_cols.value() - index - PacketSize, preverse(x)); + } + +protected: + evaluator m_argImpl; + + // If we do not reverse rows, then we do not need to know the number of rows; same for columns + // Nonetheless, in this case it is important to set to 1 such that the coeff(index) method works fine for vectors. + const variable_if_dynamic m_rows; + const variable_if_dynamic m_cols; +}; + + +// -------------------- Diagonal -------------------- + +template +struct evaluator > + : evaluator_base > +{ + typedef Diagonal XprType; + + enum { + CoeffReadCost = evaluator::CoeffReadCost, + + Flags = (unsigned int)(evaluator::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) | LinearAccessBit, + + Alignment = 0 + }; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& diagonal) + : m_argImpl(diagonal.nestedExpression()), + m_index(diagonal.index()) + { } + + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index row, Index) const + { + return m_argImpl.coeff(row + rowOffset(), row + colOffset()); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + CoeffReturnType coeff(Index index) const + { + return m_argImpl.coeff(index + rowOffset(), index + colOffset()); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index row, Index) + { + return m_argImpl.coeffRef(row + rowOffset(), row + colOffset()); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Scalar& coeffRef(Index index) + { + return m_argImpl.coeffRef(index + rowOffset(), index + colOffset()); + } + +protected: + evaluator m_argImpl; + const internal::variable_if_dynamicindex m_index; + +private: + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowOffset() const { return m_index.value() > 0 ? 0 : -m_index.value(); } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colOffset() const { return m_index.value() > 0 ? m_index.value() : 0; } +}; + + +//---------------------------------------------------------------------- +// deprecated code +//---------------------------------------------------------------------- + +// -------------------- EvalToTemp -------------------- + +// expression class for evaluating nested expression to a temporary + +template class EvalToTemp; + +template +struct traits > + : public traits +{ }; + +template +class EvalToTemp + : public dense_xpr_base >::type +{ + public: + + typedef typename dense_xpr_base::type Base; + EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp) + + explicit EvalToTemp(const ArgType& arg) + : m_arg(arg) + { } + + const ArgType& arg() const + { + return m_arg; + } + + Index rows() const + { + return m_arg.rows(); + } + + Index cols() const + { + return m_arg.cols(); + } + + private: + const ArgType& m_arg; +}; + +template +struct evaluator > + : public evaluator +{ + typedef EvalToTemp XprType; + typedef typename ArgType::PlainObject PlainObject; + typedef evaluator Base; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) + : m_result(xpr.arg()) + { + ::new (static_cast(this)) Base(m_result); + } + + // This constructor is used when nesting an EvalTo evaluator in another evaluator + EIGEN_DEVICE_FUNC evaluator(const ArgType& arg) + : m_result(arg) + { + ::new (static_cast(this)) Base(m_result); + } + +protected: + PlainObject m_result; +}; + +} // namespace internal + +} // end namespace Eigen + +#endif // EIGEN_COREEVALUATORS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/CoreIterators.h b/3rdparty/eigen3/Eigen/src/Core/CoreIterators.h new file mode 100644 index 0000000..4eb42b9 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CoreIterators.h @@ -0,0 +1,127 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2014 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_COREITERATORS_H +#define EIGEN_COREITERATORS_H + +namespace Eigen { + +/* This file contains the respective InnerIterator definition of the expressions defined in Eigen/Core + */ + +namespace internal { + +template +class inner_iterator_selector; + +} + +/** \class InnerIterator + * \brief An InnerIterator allows to loop over the element of any matrix expression. + * + * \warning To be used with care because an evaluator is constructed every time an InnerIterator iterator is constructed. + * + * TODO: add a usage example + */ +template +class InnerIterator +{ +protected: + typedef internal::inner_iterator_selector::Kind> IteratorType; + typedef internal::evaluator EvaluatorType; + typedef typename internal::traits::Scalar Scalar; +public: + /** Construct an iterator over the \a outerId -th row or column of \a xpr */ + InnerIterator(const XprType &xpr, const Index &outerId) + : m_eval(xpr), m_iter(m_eval, outerId, xpr.innerSize()) + {} + + /// \returns the value of the current coefficient. + EIGEN_STRONG_INLINE Scalar value() const { return m_iter.value(); } + /** Increment the iterator \c *this to the next non-zero coefficient. + * Explicit zeros are not skipped over. To skip explicit zeros, see class SparseView + */ + EIGEN_STRONG_INLINE InnerIterator& operator++() { m_iter.operator++(); return *this; } + /// \returns the column or row index of the current coefficient. + EIGEN_STRONG_INLINE Index index() const { return m_iter.index(); } + /// \returns the row index of the current coefficient. + EIGEN_STRONG_INLINE Index row() const { return m_iter.row(); } + /// \returns the column index of the current coefficient. + EIGEN_STRONG_INLINE Index col() const { return m_iter.col(); } + /// \returns \c true if the iterator \c *this still references a valid coefficient. + EIGEN_STRONG_INLINE operator bool() const { return m_iter; } + +protected: + EvaluatorType m_eval; + IteratorType m_iter; +private: + // If you get here, then you're not using the right InnerIterator type, e.g.: + // SparseMatrix A; + // SparseMatrix::InnerIterator it(A,0); + template InnerIterator(const EigenBase&,Index outer); +}; + +namespace internal { + +// Generic inner iterator implementation for dense objects +template +class inner_iterator_selector +{ +protected: + typedef evaluator EvaluatorType; + typedef typename traits::Scalar Scalar; + enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit }; + +public: + EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &innerSize) + : m_eval(eval), m_inner(0), m_outer(outerId), m_end(innerSize) + {} + + EIGEN_STRONG_INLINE Scalar value() const + { + return (IsRowMajor) ? m_eval.coeff(m_outer, m_inner) + : m_eval.coeff(m_inner, m_outer); + } + + EIGEN_STRONG_INLINE inner_iterator_selector& operator++() { m_inner++; return *this; } + + EIGEN_STRONG_INLINE Index index() const { return m_inner; } + inline Index row() const { return IsRowMajor ? m_outer : index(); } + inline Index col() const { return IsRowMajor ? index() : m_outer; } + + EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; } + +protected: + const EvaluatorType& m_eval; + Index m_inner; + const Index m_outer; + const Index m_end; +}; + +// For iterator-based evaluator, inner-iterator is already implemented as +// evaluator<>::InnerIterator +template +class inner_iterator_selector + : public evaluator::InnerIterator +{ +protected: + typedef typename evaluator::InnerIterator Base; + typedef evaluator EvaluatorType; + +public: + EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &/*innerSize*/) + : Base(eval, outerId) + {} +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_COREITERATORS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/CwiseBinaryOp.h b/3rdparty/eigen3/Eigen/src/Core/CwiseBinaryOp.h new file mode 100644 index 0000000..a36765e --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CwiseBinaryOp.h @@ -0,0 +1,184 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2014 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CWISE_BINARY_OP_H +#define EIGEN_CWISE_BINARY_OP_H + +namespace Eigen { + +namespace internal { +template +struct traits > +{ + // we must not inherit from traits since it has + // the potential to cause problems with MSVC + typedef typename remove_all::type Ancestor; + typedef typename traits::XprKind XprKind; + enum { + RowsAtCompileTime = traits::RowsAtCompileTime, + ColsAtCompileTime = traits::ColsAtCompileTime, + MaxRowsAtCompileTime = traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = traits::MaxColsAtCompileTime + }; + + // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor), + // we still want to handle the case when the result type is different. + typedef typename result_of< + BinaryOp( + const typename Lhs::Scalar&, + const typename Rhs::Scalar& + ) + >::type Scalar; + typedef typename cwise_promote_storage_type::StorageKind, + typename traits::StorageKind, + BinaryOp>::ret StorageKind; + typedef typename promote_index_type::StorageIndex, + typename traits::StorageIndex>::type StorageIndex; + typedef typename Lhs::Nested LhsNested; + typedef typename Rhs::Nested RhsNested; + typedef typename remove_reference::type _LhsNested; + typedef typename remove_reference::type _RhsNested; + enum { + Flags = cwise_promote_storage_order::StorageKind,typename traits::StorageKind,_LhsNested::Flags & RowMajorBit,_RhsNested::Flags & RowMajorBit>::value + }; +}; +} // end namespace internal + +template +class CwiseBinaryOpImpl; + +/** \class CwiseBinaryOp + * \ingroup Core_Module + * + * \brief Generic expression where a coefficient-wise binary operator is applied to two expressions + * + * \tparam BinaryOp template functor implementing the operator + * \tparam LhsType the type of the left-hand side + * \tparam RhsType the type of the right-hand side + * + * This class represents an expression where a coefficient-wise binary operator is applied to two expressions. + * It is the return type of binary operators, by which we mean only those binary operators where + * both the left-hand side and the right-hand side are Eigen expressions. + * For example, the return type of matrix1+matrix2 is a CwiseBinaryOp. + * + * Most of the time, this is the only way that it is used, so you typically don't have to name + * CwiseBinaryOp types explicitly. + * + * \sa MatrixBase::binaryExpr(const MatrixBase &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp + */ +template +class CwiseBinaryOp : + public CwiseBinaryOpImpl< + BinaryOp, LhsType, RhsType, + typename internal::cwise_promote_storage_type::StorageKind, + typename internal::traits::StorageKind, + BinaryOp>::ret>, + internal::no_assignment_operator +{ + public: + + typedef typename internal::remove_all::type Functor; + typedef typename internal::remove_all::type Lhs; + typedef typename internal::remove_all::type Rhs; + + typedef typename CwiseBinaryOpImpl< + BinaryOp, LhsType, RhsType, + typename internal::cwise_promote_storage_type::StorageKind, + typename internal::traits::StorageKind, + BinaryOp>::ret>::Base Base; + EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp) + + typedef typename internal::ref_selector::type LhsNested; + typedef typename internal::ref_selector::type RhsNested; + typedef typename internal::remove_reference::type _LhsNested; + typedef typename internal::remove_reference::type _RhsNested; + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp()) + : m_lhs(aLhs), m_rhs(aRhs), m_functor(func) + { + EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar); + // require the sizes to match + EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs) + eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols()); + } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index rows() const { + // return the fixed size type if available to enable compile time optimizations + if (internal::traits::type>::RowsAtCompileTime==Dynamic) + return m_rhs.rows(); + else + return m_lhs.rows(); + } + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index cols() const { + // return the fixed size type if available to enable compile time optimizations + if (internal::traits::type>::ColsAtCompileTime==Dynamic) + return m_rhs.cols(); + else + return m_lhs.cols(); + } + + /** \returns the left hand side nested expression */ + EIGEN_DEVICE_FUNC + const _LhsNested& lhs() const { return m_lhs; } + /** \returns the right hand side nested expression */ + EIGEN_DEVICE_FUNC + const _RhsNested& rhs() const { return m_rhs; } + /** \returns the functor representing the binary operation */ + EIGEN_DEVICE_FUNC + const BinaryOp& functor() const { return m_functor; } + + protected: + LhsNested m_lhs; + RhsNested m_rhs; + const BinaryOp m_functor; +}; + +// Generic API dispatcher +template +class CwiseBinaryOpImpl + : public internal::generic_xpr_base >::type +{ +public: + typedef typename internal::generic_xpr_base >::type Base; +}; + +/** replaces \c *this by \c *this - \a other. + * + * \returns a reference to \c *this + */ +template +template +EIGEN_STRONG_INLINE Derived & +MatrixBase::operator-=(const MatrixBase &other) +{ + call_assignment(derived(), other.derived(), internal::sub_assign_op()); + return derived(); +} + +/** replaces \c *this by \c *this + \a other. + * + * \returns a reference to \c *this + */ +template +template +EIGEN_STRONG_INLINE Derived & +MatrixBase::operator+=(const MatrixBase& other) +{ + call_assignment(derived(), other.derived(), internal::add_assign_op()); + return derived(); +} + +} // end namespace Eigen + +#endif // EIGEN_CWISE_BINARY_OP_H + diff --git a/3rdparty/eigen3/Eigen/src/Core/CwiseNullaryOp.h b/3rdparty/eigen3/Eigen/src/Core/CwiseNullaryOp.h new file mode 100644 index 0000000..ddd607e --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CwiseNullaryOp.h @@ -0,0 +1,866 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CWISE_NULLARY_OP_H +#define EIGEN_CWISE_NULLARY_OP_H + +namespace Eigen { + +namespace internal { +template +struct traits > : traits +{ + enum { + Flags = traits::Flags & RowMajorBit + }; +}; + +} // namespace internal + +/** \class CwiseNullaryOp + * \ingroup Core_Module + * + * \brief Generic expression of a matrix where all coefficients are defined by a functor + * + * \tparam NullaryOp template functor implementing the operator + * \tparam PlainObjectType the underlying plain matrix/array type + * + * This class represents an expression of a generic nullary operator. + * It is the return type of the Ones(), Zero(), Constant(), Identity() and Random() methods, + * and most of the time this is the only way it is used. + * + * However, if you want to write a function returning such an expression, you + * will need to use this class. + * + * The functor NullaryOp must expose one of the following method: + + + + +
    \c operator()() if the procedural generation does not depend on the coefficient entries (e.g., random numbers)
    \c operator()(Index i)if the procedural generation makes sense for vectors only and that it depends on the coefficient index \c i (e.g., linspace)
    \c operator()(Index i,Index j)if the procedural generation depends on the matrix coordinates \c i, \c j (e.g., to generate a checkerboard with 0 and 1)
    + * It is also possible to expose the last two operators if the generation makes sense for matrices but can be optimized for vectors. + * + * See DenseBase::NullaryExpr(Index,const CustomNullaryOp&) for an example binding + * C++11 random number generators. + * + * A nullary expression can also be used to implement custom sophisticated matrix manipulations + * that cannot be covered by the existing set of natively supported matrix manipulations. + * See this \ref TopicCustomizing_NullaryExpr "page" for some examples and additional explanations + * on the behavior of CwiseNullaryOp. + * + * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr + */ +template +class CwiseNullaryOp : public internal::dense_xpr_base< CwiseNullaryOp >::type, internal::no_assignment_operator +{ + public: + + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp) + + EIGEN_DEVICE_FUNC + CwiseNullaryOp(Index rows, Index cols, const NullaryOp& func = NullaryOp()) + : m_rows(rows), m_cols(cols), m_functor(func) + { + eigen_assert(rows >= 0 + && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) + && cols >= 0 + && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); + } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index rows() const { return m_rows.value(); } + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index cols() const { return m_cols.value(); } + + /** \returns the functor representing the nullary operation */ + EIGEN_DEVICE_FUNC + const NullaryOp& functor() const { return m_functor; } + + protected: + const internal::variable_if_dynamic m_rows; + const internal::variable_if_dynamic m_cols; + const NullaryOp m_functor; +}; + + +/** \returns an expression of a matrix defined by a custom functor \a func + * + * The parameters \a rows and \a cols are the number of rows and of columns of + * the returned matrix. Must be compatible with this MatrixBase type. + * + * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, + * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used + * instead. + * + * The template parameter \a CustomNullaryOp is the type of the functor. + * + * \sa class CwiseNullaryOp + */ +template +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseNullaryOp::PlainObject> +DenseBase::NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func) +{ + return CwiseNullaryOp(rows, cols, func); +} + +/** \returns an expression of a matrix defined by a custom functor \a func + * + * The parameter \a size is the size of the returned vector. + * Must be compatible with this MatrixBase type. + * + * \only_for_vectors + * + * This variant is meant to be used for dynamic-size vector types. For fixed-size types, + * it is redundant to pass \a size as argument, so Zero() should be used + * instead. + * + * The template parameter \a CustomNullaryOp is the type of the functor. + * + * Here is an example with C++11 random generators: \include random_cpp11.cpp + * Output: \verbinclude random_cpp11.out + * + * \sa class CwiseNullaryOp + */ +template +template +EIGEN_STRONG_INLINE const CwiseNullaryOp::PlainObject> +DenseBase::NullaryExpr(Index size, const CustomNullaryOp& func) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + if(RowsAtCompileTime == 1) return CwiseNullaryOp(1, size, func); + else return CwiseNullaryOp(size, 1, func); +} + +/** \returns an expression of a matrix defined by a custom functor \a func + * + * This variant is only for fixed-size DenseBase types. For dynamic-size types, you + * need to use the variants taking size arguments. + * + * The template parameter \a CustomNullaryOp is the type of the functor. + * + * \sa class CwiseNullaryOp + */ +template +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseNullaryOp::PlainObject> +DenseBase::NullaryExpr(const CustomNullaryOp& func) +{ + return CwiseNullaryOp(RowsAtCompileTime, ColsAtCompileTime, func); +} + +/** \returns an expression of a constant matrix of value \a value + * + * The parameters \a rows and \a cols are the number of rows and of columns of + * the returned matrix. Must be compatible with this DenseBase type. + * + * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, + * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used + * instead. + * + * The template parameter \a CustomNullaryOp is the type of the functor. + * + * \sa class CwiseNullaryOp + */ +template +EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Constant(Index rows, Index cols, const Scalar& value) +{ + return DenseBase::NullaryExpr(rows, cols, internal::scalar_constant_op(value)); +} + +/** \returns an expression of a constant matrix of value \a value + * + * The parameter \a size is the size of the returned vector. + * Must be compatible with this DenseBase type. + * + * \only_for_vectors + * + * This variant is meant to be used for dynamic-size vector types. For fixed-size types, + * it is redundant to pass \a size as argument, so Zero() should be used + * instead. + * + * The template parameter \a CustomNullaryOp is the type of the functor. + * + * \sa class CwiseNullaryOp + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Constant(Index size, const Scalar& value) +{ + return DenseBase::NullaryExpr(size, internal::scalar_constant_op(value)); +} + +/** \returns an expression of a constant matrix of value \a value + * + * This variant is only for fixed-size DenseBase types. For dynamic-size types, you + * need to use the variants taking size arguments. + * + * The template parameter \a CustomNullaryOp is the type of the functor. + * + * \sa class CwiseNullaryOp + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Constant(const Scalar& value) +{ + EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) + return DenseBase::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op(value)); +} + +/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(Index,const Scalar&,const Scalar&) + * + * \sa LinSpaced(Index,Scalar,Scalar), setLinSpaced(Index,const Scalar&,const Scalar&) + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::RandomAccessLinSpacedReturnType +DenseBase::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + return DenseBase::NullaryExpr(size, internal::linspaced_op(low,high,size)); +} + +/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(const Scalar&,const Scalar&) + * + * \sa LinSpaced(Scalar,Scalar) + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::RandomAccessLinSpacedReturnType +DenseBase::LinSpaced(Sequential_t, const Scalar& low, const Scalar& high) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) + return DenseBase::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op(low,high,Derived::SizeAtCompileTime)); +} + +/** + * \brief Sets a linearly spaced vector. + * + * The function generates 'size' equally spaced values in the closed interval [low,high]. + * When size is set to 1, a vector of length 1 containing 'high' is returned. + * + * \only_for_vectors + * + * Example: \include DenseBase_LinSpaced.cpp + * Output: \verbinclude DenseBase_LinSpaced.out + * + * For integer scalar types, an even spacing is possible if and only if the length of the range, + * i.e., \c high-low is a scalar multiple of \c size-1, or if \c size is a scalar multiple of the + * number of values \c high-low+1 (meaning each value can be repeated the same number of time). + * If one of these two considions is not satisfied, then \c high is lowered to the largest value + * satisfying one of this constraint. + * Here are some examples: + * + * Example: \include DenseBase_LinSpacedInt.cpp + * Output: \verbinclude DenseBase_LinSpacedInt.out + * + * \sa setLinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::RandomAccessLinSpacedReturnType +DenseBase::LinSpaced(Index size, const Scalar& low, const Scalar& high) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + return DenseBase::NullaryExpr(size, internal::linspaced_op(low,high,size)); +} + +/** + * \copydoc DenseBase::LinSpaced(Index, const Scalar&, const Scalar&) + * Special version for fixed size types which does not require the size parameter. + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::RandomAccessLinSpacedReturnType +DenseBase::LinSpaced(const Scalar& low, const Scalar& high) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) + return DenseBase::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op(low,high,Derived::SizeAtCompileTime)); +} + +/** \returns true if all coefficients in this matrix are approximately equal to \a val, to within precision \a prec */ +template +EIGEN_DEVICE_FUNC bool DenseBase::isApproxToConstant +(const Scalar& val, const RealScalar& prec) const +{ + typename internal::nested_eval::type self(derived()); + for(Index j = 0; j < cols(); ++j) + for(Index i = 0; i < rows(); ++i) + if(!internal::isApprox(self.coeff(i, j), val, prec)) + return false; + return true; +} + +/** This is just an alias for isApproxToConstant(). + * + * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */ +template +EIGEN_DEVICE_FUNC bool DenseBase::isConstant +(const Scalar& val, const RealScalar& prec) const +{ + return isApproxToConstant(val, prec); +} + +/** Alias for setConstant(): sets all coefficients in this expression to \a val. + * + * \sa setConstant(), Constant(), class CwiseNullaryOp + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void DenseBase::fill(const Scalar& val) +{ + setConstant(val); +} + +/** Sets all coefficients in this expression to value \a val. + * + * \sa fill(), setConstant(Index,const Scalar&), setConstant(Index,Index,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase::setConstant(const Scalar& val) +{ + return derived() = Constant(rows(), cols(), val); +} + +/** Resizes to the given \a size, and sets all coefficients in this expression to the given value \a val. + * + * \only_for_vectors + * + * Example: \include Matrix_setConstant_int.cpp + * Output: \verbinclude Matrix_setConstant_int.out + * + * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&) + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setConstant(Index size, const Scalar& val) +{ + resize(size); + return setConstant(val); +} + +/** Resizes to the given size, and sets all coefficients in this expression to the given value \a val. + * + * \param rows the new number of rows + * \param cols the new number of columns + * \param val the value to which all coefficients are set + * + * Example: \include Matrix_setConstant_int_int.cpp + * Output: \verbinclude Matrix_setConstant_int_int.out + * + * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&) + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setConstant(Index rows, Index cols, const Scalar& val) +{ + resize(rows, cols); + return setConstant(val); +} + +/** + * \brief Sets a linearly spaced vector. + * + * The function generates 'size' equally spaced values in the closed interval [low,high]. + * When size is set to 1, a vector of length 1 containing 'high' is returned. + * + * \only_for_vectors + * + * Example: \include DenseBase_setLinSpaced.cpp + * Output: \verbinclude DenseBase_setLinSpaced.out + * + * For integer scalar types, do not miss the explanations on the definition + * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink. + * + * \sa LinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase::setLinSpaced(Index newSize, const Scalar& low, const Scalar& high) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + return derived() = Derived::NullaryExpr(newSize, internal::linspaced_op(low,high,newSize)); +} + +/** + * \brief Sets a linearly spaced vector. + * + * The function fills \c *this with equally spaced values in the closed interval [low,high]. + * When size is set to 1, a vector of length 1 containing 'high' is returned. + * + * \only_for_vectors + * + * For integer scalar types, do not miss the explanations on the definition + * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink. + * + * \sa LinSpaced(Index,const Scalar&,const Scalar&), setLinSpaced(Index, const Scalar&, const Scalar&), CwiseNullaryOp + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase::setLinSpaced(const Scalar& low, const Scalar& high) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + return setLinSpaced(size(), low, high); +} + +// zero: + +/** \returns an expression of a zero matrix. + * + * The parameters \a rows and \a cols are the number of rows and of columns of + * the returned matrix. Must be compatible with this MatrixBase type. + * + * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, + * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used + * instead. + * + * Example: \include MatrixBase_zero_int_int.cpp + * Output: \verbinclude MatrixBase_zero_int_int.out + * + * \sa Zero(), Zero(Index) + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Zero(Index rows, Index cols) +{ + return Constant(rows, cols, Scalar(0)); +} + +/** \returns an expression of a zero vector. + * + * The parameter \a size is the size of the returned vector. + * Must be compatible with this MatrixBase type. + * + * \only_for_vectors + * + * This variant is meant to be used for dynamic-size vector types. For fixed-size types, + * it is redundant to pass \a size as argument, so Zero() should be used + * instead. + * + * Example: \include MatrixBase_zero_int.cpp + * Output: \verbinclude MatrixBase_zero_int.out + * + * \sa Zero(), Zero(Index,Index) + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Zero(Index size) +{ + return Constant(size, Scalar(0)); +} + +/** \returns an expression of a fixed-size zero matrix or vector. + * + * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you + * need to use the variants taking size arguments. + * + * Example: \include MatrixBase_zero.cpp + * Output: \verbinclude MatrixBase_zero.out + * + * \sa Zero(Index), Zero(Index,Index) + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Zero() +{ + return Constant(Scalar(0)); +} + +/** \returns true if *this is approximately equal to the zero matrix, + * within the precision given by \a prec. + * + * Example: \include MatrixBase_isZero.cpp + * Output: \verbinclude MatrixBase_isZero.out + * + * \sa class CwiseNullaryOp, Zero() + */ +template +EIGEN_DEVICE_FUNC bool DenseBase::isZero(const RealScalar& prec) const +{ + typename internal::nested_eval::type self(derived()); + for(Index j = 0; j < cols(); ++j) + for(Index i = 0; i < rows(); ++i) + if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast(1), prec)) + return false; + return true; +} + +/** Sets all coefficients in this expression to zero. + * + * Example: \include MatrixBase_setZero.cpp + * Output: \verbinclude MatrixBase_setZero.out + * + * \sa class CwiseNullaryOp, Zero() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase::setZero() +{ + return setConstant(Scalar(0)); +} + +/** Resizes to the given \a size, and sets all coefficients in this expression to zero. + * + * \only_for_vectors + * + * Example: \include Matrix_setZero_int.cpp + * Output: \verbinclude Matrix_setZero_int.out + * + * \sa DenseBase::setZero(), setZero(Index,Index), class CwiseNullaryOp, DenseBase::Zero() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setZero(Index newSize) +{ + resize(newSize); + return setConstant(Scalar(0)); +} + +/** Resizes to the given size, and sets all coefficients in this expression to zero. + * + * \param rows the new number of rows + * \param cols the new number of columns + * + * Example: \include Matrix_setZero_int_int.cpp + * Output: \verbinclude Matrix_setZero_int_int.out + * + * \sa DenseBase::setZero(), setZero(Index), class CwiseNullaryOp, DenseBase::Zero() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setZero(Index rows, Index cols) +{ + resize(rows, cols); + return setConstant(Scalar(0)); +} + +// ones: + +/** \returns an expression of a matrix where all coefficients equal one. + * + * The parameters \a rows and \a cols are the number of rows and of columns of + * the returned matrix. Must be compatible with this MatrixBase type. + * + * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, + * it is redundant to pass \a rows and \a cols as arguments, so Ones() should be used + * instead. + * + * Example: \include MatrixBase_ones_int_int.cpp + * Output: \verbinclude MatrixBase_ones_int_int.out + * + * \sa Ones(), Ones(Index), isOnes(), class Ones + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Ones(Index rows, Index cols) +{ + return Constant(rows, cols, Scalar(1)); +} + +/** \returns an expression of a vector where all coefficients equal one. + * + * The parameter \a newSize is the size of the returned vector. + * Must be compatible with this MatrixBase type. + * + * \only_for_vectors + * + * This variant is meant to be used for dynamic-size vector types. For fixed-size types, + * it is redundant to pass \a size as argument, so Ones() should be used + * instead. + * + * Example: \include MatrixBase_ones_int.cpp + * Output: \verbinclude MatrixBase_ones_int.out + * + * \sa Ones(), Ones(Index,Index), isOnes(), class Ones + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Ones(Index newSize) +{ + return Constant(newSize, Scalar(1)); +} + +/** \returns an expression of a fixed-size matrix or vector where all coefficients equal one. + * + * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you + * need to use the variants taking size arguments. + * + * Example: \include MatrixBase_ones.cpp + * Output: \verbinclude MatrixBase_ones.out + * + * \sa Ones(Index), Ones(Index,Index), isOnes(), class Ones + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType +DenseBase::Ones() +{ + return Constant(Scalar(1)); +} + +/** \returns true if *this is approximately equal to the matrix where all coefficients + * are equal to 1, within the precision given by \a prec. + * + * Example: \include MatrixBase_isOnes.cpp + * Output: \verbinclude MatrixBase_isOnes.out + * + * \sa class CwiseNullaryOp, Ones() + */ +template +EIGEN_DEVICE_FUNC bool DenseBase::isOnes +(const RealScalar& prec) const +{ + return isApproxToConstant(Scalar(1), prec); +} + +/** Sets all coefficients in this expression to one. + * + * Example: \include MatrixBase_setOnes.cpp + * Output: \verbinclude MatrixBase_setOnes.out + * + * \sa class CwiseNullaryOp, Ones() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase::setOnes() +{ + return setConstant(Scalar(1)); +} + +/** Resizes to the given \a newSize, and sets all coefficients in this expression to one. + * + * \only_for_vectors + * + * Example: \include Matrix_setOnes_int.cpp + * Output: \verbinclude Matrix_setOnes_int.out + * + * \sa MatrixBase::setOnes(), setOnes(Index,Index), class CwiseNullaryOp, MatrixBase::Ones() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setOnes(Index newSize) +{ + resize(newSize); + return setConstant(Scalar(1)); +} + +/** Resizes to the given size, and sets all coefficients in this expression to one. + * + * \param rows the new number of rows + * \param cols the new number of columns + * + * Example: \include Matrix_setOnes_int_int.cpp + * Output: \verbinclude Matrix_setOnes_int_int.out + * + * \sa MatrixBase::setOnes(), setOnes(Index), class CwiseNullaryOp, MatrixBase::Ones() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setOnes(Index rows, Index cols) +{ + resize(rows, cols); + return setConstant(Scalar(1)); +} + +// Identity: + +/** \returns an expression of the identity matrix (not necessarily square). + * + * The parameters \a rows and \a cols are the number of rows and of columns of + * the returned matrix. Must be compatible with this MatrixBase type. + * + * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, + * it is redundant to pass \a rows and \a cols as arguments, so Identity() should be used + * instead. + * + * Example: \include MatrixBase_identity_int_int.cpp + * Output: \verbinclude MatrixBase_identity_int_int.out + * + * \sa Identity(), setIdentity(), isIdentity() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::IdentityReturnType +MatrixBase::Identity(Index rows, Index cols) +{ + return DenseBase::NullaryExpr(rows, cols, internal::scalar_identity_op()); +} + +/** \returns an expression of the identity matrix (not necessarily square). + * + * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you + * need to use the variant taking size arguments. + * + * Example: \include MatrixBase_identity.cpp + * Output: \verbinclude MatrixBase_identity.out + * + * \sa Identity(Index,Index), setIdentity(), isIdentity() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::IdentityReturnType +MatrixBase::Identity() +{ + EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) + return MatrixBase::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op()); +} + +/** \returns true if *this is approximately equal to the identity matrix + * (not necessarily square), + * within the precision given by \a prec. + * + * Example: \include MatrixBase_isIdentity.cpp + * Output: \verbinclude MatrixBase_isIdentity.out + * + * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), setIdentity() + */ +template +bool MatrixBase::isIdentity +(const RealScalar& prec) const +{ + typename internal::nested_eval::type self(derived()); + for(Index j = 0; j < cols(); ++j) + { + for(Index i = 0; i < rows(); ++i) + { + if(i == j) + { + if(!internal::isApprox(self.coeff(i, j), static_cast(1), prec)) + return false; + } + else + { + if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast(1), prec)) + return false; + } + } + } + return true; +} + +namespace internal { + +template=16)> +struct setIdentity_impl +{ + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE Derived& run(Derived& m) + { + return m = Derived::Identity(m.rows(), m.cols()); + } +}; + +template +struct setIdentity_impl +{ + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE Derived& run(Derived& m) + { + m.setZero(); + const Index size = numext::mini(m.rows(), m.cols()); + for(Index i = 0; i < size; ++i) m.coeffRef(i,i) = typename Derived::Scalar(1); + return m; + } +}; + +} // end namespace internal + +/** Writes the identity expression (not necessarily square) into *this. + * + * Example: \include MatrixBase_setIdentity.cpp + * Output: \verbinclude MatrixBase_setIdentity.out + * + * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), isIdentity() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase::setIdentity() +{ + return internal::setIdentity_impl::run(derived()); +} + +/** \brief Resizes to the given size, and writes the identity expression (not necessarily square) into *this. + * + * \param rows the new number of rows + * \param cols the new number of columns + * + * Example: \include Matrix_setIdentity_int_int.cpp + * Output: \verbinclude Matrix_setIdentity_int_int.out + * + * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Identity() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase::setIdentity(Index rows, Index cols) +{ + derived().resize(rows, cols); + return setIdentity(); +} + +/** \returns an expression of the i-th unit (basis) vector. + * + * \only_for_vectors + * + * \sa MatrixBase::Unit(Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::BasisReturnType MatrixBase::Unit(Index newSize, Index i) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + return BasisReturnType(SquareMatrixType::Identity(newSize,newSize), i); +} + +/** \returns an expression of the i-th unit (basis) vector. + * + * \only_for_vectors + * + * This variant is for fixed-size vector only. + * + * \sa MatrixBase::Unit(Index,Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::BasisReturnType MatrixBase::Unit(Index i) +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + return BasisReturnType(SquareMatrixType::Identity(),i); +} + +/** \returns an expression of the X axis unit vector (1{,0}^*) + * + * \only_for_vectors + * + * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::BasisReturnType MatrixBase::UnitX() +{ return Derived::Unit(0); } + +/** \returns an expression of the Y axis unit vector (0,1{,0}^*) + * + * \only_for_vectors + * + * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::BasisReturnType MatrixBase::UnitY() +{ return Derived::Unit(1); } + +/** \returns an expression of the Z axis unit vector (0,0,1{,0}^*) + * + * \only_for_vectors + * + * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::BasisReturnType MatrixBase::UnitZ() +{ return Derived::Unit(2); } + +/** \returns an expression of the W axis unit vector (0,0,0,1) + * + * \only_for_vectors + * + * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() + */ +template +EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase::BasisReturnType MatrixBase::UnitW() +{ return Derived::Unit(3); } + +} // end namespace Eigen + +#endif // EIGEN_CWISE_NULLARY_OP_H diff --git a/3rdparty/eigen3/Eigen/src/Core/CwiseTernaryOp.h b/3rdparty/eigen3/Eigen/src/Core/CwiseTernaryOp.h new file mode 100644 index 0000000..9f3576f --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CwiseTernaryOp.h @@ -0,0 +1,197 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2014 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// Copyright (C) 2016 Eugene Brevdo +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CWISE_TERNARY_OP_H +#define EIGEN_CWISE_TERNARY_OP_H + +namespace Eigen { + +namespace internal { +template +struct traits > { + // we must not inherit from traits since it has + // the potential to cause problems with MSVC + typedef typename remove_all::type Ancestor; + typedef typename traits::XprKind XprKind; + enum { + RowsAtCompileTime = traits::RowsAtCompileTime, + ColsAtCompileTime = traits::ColsAtCompileTime, + MaxRowsAtCompileTime = traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = traits::MaxColsAtCompileTime + }; + + // even though we require Arg1, Arg2, and Arg3 to have the same scalar type + // (see CwiseTernaryOp constructor), + // we still want to handle the case when the result type is different. + typedef typename result_of::type Scalar; + + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::StorageIndex StorageIndex; + + typedef typename Arg1::Nested Arg1Nested; + typedef typename Arg2::Nested Arg2Nested; + typedef typename Arg3::Nested Arg3Nested; + typedef typename remove_reference::type _Arg1Nested; + typedef typename remove_reference::type _Arg2Nested; + typedef typename remove_reference::type _Arg3Nested; + enum { Flags = _Arg1Nested::Flags & RowMajorBit }; +}; +} // end namespace internal + +template +class CwiseTernaryOpImpl; + +/** \class CwiseTernaryOp + * \ingroup Core_Module + * + * \brief Generic expression where a coefficient-wise ternary operator is + * applied to two expressions + * + * \tparam TernaryOp template functor implementing the operator + * \tparam Arg1Type the type of the first argument + * \tparam Arg2Type the type of the second argument + * \tparam Arg3Type the type of the third argument + * + * This class represents an expression where a coefficient-wise ternary + * operator is applied to three expressions. + * It is the return type of ternary operators, by which we mean only those + * ternary operators where + * all three arguments are Eigen expressions. + * For example, the return type of betainc(matrix1, matrix2, matrix3) is a + * CwiseTernaryOp. + * + * Most of the time, this is the only way that it is used, so you typically + * don't have to name + * CwiseTernaryOp types explicitly. + * + * \sa MatrixBase::ternaryExpr(const MatrixBase &, const + * MatrixBase &, const CustomTernaryOp &) const, class CwiseBinaryOp, + * class CwiseUnaryOp, class CwiseNullaryOp + */ +template +class CwiseTernaryOp : public CwiseTernaryOpImpl< + TernaryOp, Arg1Type, Arg2Type, Arg3Type, + typename internal::traits::StorageKind>, + internal::no_assignment_operator +{ + public: + typedef typename internal::remove_all::type Arg1; + typedef typename internal::remove_all::type Arg2; + typedef typename internal::remove_all::type Arg3; + + typedef typename CwiseTernaryOpImpl< + TernaryOp, Arg1Type, Arg2Type, Arg3Type, + typename internal::traits::StorageKind>::Base Base; + EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseTernaryOp) + + typedef typename internal::ref_selector::type Arg1Nested; + typedef typename internal::ref_selector::type Arg2Nested; + typedef typename internal::ref_selector::type Arg3Nested; + typedef typename internal::remove_reference::type _Arg1Nested; + typedef typename internal::remove_reference::type _Arg2Nested; + typedef typename internal::remove_reference::type _Arg3Nested; + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CwiseTernaryOp(const Arg1& a1, const Arg2& a2, + const Arg3& a3, + const TernaryOp& func = TernaryOp()) + : m_arg1(a1), m_arg2(a2), m_arg3(a3), m_functor(func) { + // require the sizes to match + EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg2) + EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg3) + + // The index types should match + EIGEN_STATIC_ASSERT((internal::is_same< + typename internal::traits::StorageKind, + typename internal::traits::StorageKind>::value), + STORAGE_KIND_MUST_MATCH) + EIGEN_STATIC_ASSERT((internal::is_same< + typename internal::traits::StorageKind, + typename internal::traits::StorageKind>::value), + STORAGE_KIND_MUST_MATCH) + + eigen_assert(a1.rows() == a2.rows() && a1.cols() == a2.cols() && + a1.rows() == a3.rows() && a1.cols() == a3.cols()); + } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index rows() const { + // return the fixed size type if available to enable compile time + // optimizations + if (internal::traits::type>:: + RowsAtCompileTime == Dynamic && + internal::traits::type>:: + RowsAtCompileTime == Dynamic) + return m_arg3.rows(); + else if (internal::traits::type>:: + RowsAtCompileTime == Dynamic && + internal::traits::type>:: + RowsAtCompileTime == Dynamic) + return m_arg2.rows(); + else + return m_arg1.rows(); + } + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index cols() const { + // return the fixed size type if available to enable compile time + // optimizations + if (internal::traits::type>:: + ColsAtCompileTime == Dynamic && + internal::traits::type>:: + ColsAtCompileTime == Dynamic) + return m_arg3.cols(); + else if (internal::traits::type>:: + ColsAtCompileTime == Dynamic && + internal::traits::type>:: + ColsAtCompileTime == Dynamic) + return m_arg2.cols(); + else + return m_arg1.cols(); + } + + /** \returns the first argument nested expression */ + EIGEN_DEVICE_FUNC + const _Arg1Nested& arg1() const { return m_arg1; } + /** \returns the first argument nested expression */ + EIGEN_DEVICE_FUNC + const _Arg2Nested& arg2() const { return m_arg2; } + /** \returns the third argument nested expression */ + EIGEN_DEVICE_FUNC + const _Arg3Nested& arg3() const { return m_arg3; } + /** \returns the functor representing the ternary operation */ + EIGEN_DEVICE_FUNC + const TernaryOp& functor() const { return m_functor; } + + protected: + Arg1Nested m_arg1; + Arg2Nested m_arg2; + Arg3Nested m_arg3; + const TernaryOp m_functor; +}; + +// Generic API dispatcher +template +class CwiseTernaryOpImpl + : public internal::generic_xpr_base< + CwiseTernaryOp >::type { + public: + typedef typename internal::generic_xpr_base< + CwiseTernaryOp >::type Base; +}; + +} // end namespace Eigen + +#endif // EIGEN_CWISE_TERNARY_OP_H diff --git a/3rdparty/eigen3/Eigen/src/Core/CwiseUnaryOp.h b/3rdparty/eigen3/Eigen/src/Core/CwiseUnaryOp.h new file mode 100644 index 0000000..1d2dd19 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CwiseUnaryOp.h @@ -0,0 +1,103 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2014 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CWISE_UNARY_OP_H +#define EIGEN_CWISE_UNARY_OP_H + +namespace Eigen { + +namespace internal { +template +struct traits > + : traits +{ + typedef typename result_of< + UnaryOp(const typename XprType::Scalar&) + >::type Scalar; + typedef typename XprType::Nested XprTypeNested; + typedef typename remove_reference::type _XprTypeNested; + enum { + Flags = _XprTypeNested::Flags & RowMajorBit + }; +}; +} + +template +class CwiseUnaryOpImpl; + +/** \class CwiseUnaryOp + * \ingroup Core_Module + * + * \brief Generic expression where a coefficient-wise unary operator is applied to an expression + * + * \tparam UnaryOp template functor implementing the operator + * \tparam XprType the type of the expression to which we are applying the unary operator + * + * This class represents an expression where a unary operator is applied to an expression. + * It is the return type of all operations taking exactly 1 input expression, regardless of the + * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix + * is considered unary, because only the right-hand side is an expression, and its + * return type is a specialization of CwiseUnaryOp. + * + * Most of the time, this is the only way that it is used, so you typically don't have to name + * CwiseUnaryOp types explicitly. + * + * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp + */ +template +class CwiseUnaryOp : public CwiseUnaryOpImpl::StorageKind>, internal::no_assignment_operator +{ + public: + + typedef typename CwiseUnaryOpImpl::StorageKind>::Base Base; + EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp) + typedef typename internal::ref_selector::type XprTypeNested; + typedef typename internal::remove_all::type NestedExpression; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + explicit CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp()) + : m_xpr(xpr), m_functor(func) {} + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Index rows() const { return m_xpr.rows(); } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Index cols() const { return m_xpr.cols(); } + + /** \returns the functor representing the unary operation */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + const UnaryOp& functor() const { return m_functor; } + + /** \returns the nested expression */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + const typename internal::remove_all::type& + nestedExpression() const { return m_xpr; } + + /** \returns the nested expression */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + typename internal::remove_all::type& + nestedExpression() { return m_xpr; } + + protected: + XprTypeNested m_xpr; + const UnaryOp m_functor; +}; + +// Generic API dispatcher +template +class CwiseUnaryOpImpl + : public internal::generic_xpr_base >::type +{ +public: + typedef typename internal::generic_xpr_base >::type Base; +}; + +} // end namespace Eigen + +#endif // EIGEN_CWISE_UNARY_OP_H diff --git a/3rdparty/eigen3/Eigen/src/Core/CwiseUnaryView.h b/3rdparty/eigen3/Eigen/src/Core/CwiseUnaryView.h new file mode 100644 index 0000000..2710330 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/CwiseUnaryView.h @@ -0,0 +1,128 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_CWISE_UNARY_VIEW_H +#define EIGEN_CWISE_UNARY_VIEW_H + +namespace Eigen { + +namespace internal { +template +struct traits > + : traits +{ + typedef typename result_of< + ViewOp(const typename traits::Scalar&) + >::type Scalar; + typedef typename MatrixType::Nested MatrixTypeNested; + typedef typename remove_all::type _MatrixTypeNested; + enum { + FlagsLvalueBit = is_lvalue::value ? LvalueBit : 0, + Flags = traits<_MatrixTypeNested>::Flags & (RowMajorBit | FlagsLvalueBit | DirectAccessBit), // FIXME DirectAccessBit should not be handled by expressions + MatrixTypeInnerStride = inner_stride_at_compile_time::ret, + // need to cast the sizeof's from size_t to int explicitly, otherwise: + // "error: no integral type can represent all of the enumerator values + InnerStrideAtCompileTime = MatrixTypeInnerStride == Dynamic + ? int(Dynamic) + : int(MatrixTypeInnerStride) * int(sizeof(typename traits::Scalar) / sizeof(Scalar)), + OuterStrideAtCompileTime = outer_stride_at_compile_time::ret == Dynamic + ? int(Dynamic) + : outer_stride_at_compile_time::ret * int(sizeof(typename traits::Scalar) / sizeof(Scalar)) + }; +}; +} + +template +class CwiseUnaryViewImpl; + +/** \class CwiseUnaryView + * \ingroup Core_Module + * + * \brief Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector + * + * \tparam ViewOp template functor implementing the view + * \tparam MatrixType the type of the matrix we are applying the unary operator + * + * This class represents a lvalue expression of a generic unary view operator of a matrix or a vector. + * It is the return type of real() and imag(), and most of the time this is the only way it is used. + * + * \sa MatrixBase::unaryViewExpr(const CustomUnaryOp &) const, class CwiseUnaryOp + */ +template +class CwiseUnaryView : public CwiseUnaryViewImpl::StorageKind> +{ + public: + + typedef typename CwiseUnaryViewImpl::StorageKind>::Base Base; + EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryView) + typedef typename internal::ref_selector::non_const_type MatrixTypeNested; + typedef typename internal::remove_all::type NestedExpression; + + explicit inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = ViewOp()) + : m_matrix(mat), m_functor(func) {} + + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryView) + + EIGEN_STRONG_INLINE Index rows() const { return m_matrix.rows(); } + EIGEN_STRONG_INLINE Index cols() const { return m_matrix.cols(); } + + /** \returns the functor representing unary operation */ + const ViewOp& functor() const { return m_functor; } + + /** \returns the nested expression */ + const typename internal::remove_all::type& + nestedExpression() const { return m_matrix; } + + /** \returns the nested expression */ + typename internal::remove_reference::type& + nestedExpression() { return m_matrix.const_cast_derived(); } + + protected: + MatrixTypeNested m_matrix; + ViewOp m_functor; +}; + +// Generic API dispatcher +template +class CwiseUnaryViewImpl + : public internal::generic_xpr_base >::type +{ +public: + typedef typename internal::generic_xpr_base >::type Base; +}; + +template +class CwiseUnaryViewImpl + : public internal::dense_xpr_base< CwiseUnaryView >::type +{ + public: + + typedef CwiseUnaryView Derived; + typedef typename internal::dense_xpr_base< CwiseUnaryView >::type Base; + + EIGEN_DENSE_PUBLIC_INTERFACE(Derived) + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryViewImpl) + + EIGEN_DEVICE_FUNC inline Scalar* data() { return &(this->coeffRef(0)); } + EIGEN_DEVICE_FUNC inline const Scalar* data() const { return &(this->coeff(0)); } + + EIGEN_DEVICE_FUNC inline Index innerStride() const + { + return derived().nestedExpression().innerStride() * sizeof(typename internal::traits::Scalar) / sizeof(Scalar); + } + + EIGEN_DEVICE_FUNC inline Index outerStride() const + { + return derived().nestedExpression().outerStride() * sizeof(typename internal::traits::Scalar) / sizeof(Scalar); + } +}; + +} // end namespace Eigen + +#endif // EIGEN_CWISE_UNARY_VIEW_H diff --git a/3rdparty/eigen3/Eigen/src/Core/DenseBase.h b/3rdparty/eigen3/Eigen/src/Core/DenseBase.h new file mode 100644 index 0000000..90066ae --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/DenseBase.h @@ -0,0 +1,611 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2007-2010 Benoit Jacob +// Copyright (C) 2008-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_DENSEBASE_H +#define EIGEN_DENSEBASE_H + +namespace Eigen { + +namespace internal { + +// The index type defined by EIGEN_DEFAULT_DENSE_INDEX_TYPE must be a signed type. +// This dummy function simply aims at checking that at compile time. +static inline void check_DenseIndex_is_signed() { + EIGEN_STATIC_ASSERT(NumTraits::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE); +} + +} // end namespace internal + +/** \class DenseBase + * \ingroup Core_Module + * + * \brief Base class for all dense matrices, vectors, and arrays + * + * This class is the base that is inherited by all dense objects (matrix, vector, arrays, + * and related expression types). The common Eigen API for dense objects is contained in this class. + * + * \tparam Derived is the derived type, e.g., a matrix type or an expression. + * + * This class can be extended with the help of the plugin mechanism described on the page + * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_DENSEBASE_PLUGIN. + * + * \sa \blank \ref TopicClassHierarchy + */ +template class DenseBase +#ifndef EIGEN_PARSED_BY_DOXYGEN + : public DenseCoeffsBase +#else + : public DenseCoeffsBase +#endif // not EIGEN_PARSED_BY_DOXYGEN +{ + public: + + /** Inner iterator type to iterate over the coefficients of a row or column. + * \sa class InnerIterator + */ + typedef Eigen::InnerIterator InnerIterator; + + typedef typename internal::traits::StorageKind StorageKind; + + /** + * \brief The type used to store indices + * \details This typedef is relevant for types that store multiple indices such as + * PermutationMatrix or Transpositions, otherwise it defaults to Eigen::Index + * \sa \blank \ref TopicPreprocessorDirectives, Eigen::Index, SparseMatrixBase. + */ + typedef typename internal::traits::StorageIndex StorageIndex; + + /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex, etc. */ + typedef typename internal::traits::Scalar Scalar; + + /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex, etc. + * + * It is an alias for the Scalar type */ + typedef Scalar value_type; + + typedef typename NumTraits::Real RealScalar; + typedef DenseCoeffsBase Base; + + using Base::derived; + using Base::const_cast_derived; + using Base::rows; + using Base::cols; + using Base::size; + using Base::rowIndexByOuterInner; + using Base::colIndexByOuterInner; + using Base::coeff; + using Base::coeffByOuterInner; + using Base::operator(); + using Base::operator[]; + using Base::x; + using Base::y; + using Base::z; + using Base::w; + using Base::stride; + using Base::innerStride; + using Base::outerStride; + using Base::rowStride; + using Base::colStride; + typedef typename Base::CoeffReturnType CoeffReturnType; + + enum { + + RowsAtCompileTime = internal::traits::RowsAtCompileTime, + /**< The number of rows at compile-time. This is just a copy of the value provided + * by the \a Derived type. If a value is not known at compile-time, + * it is set to the \a Dynamic constant. + * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */ + + ColsAtCompileTime = internal::traits::ColsAtCompileTime, + /**< The number of columns at compile-time. This is just a copy of the value provided + * by the \a Derived type. If a value is not known at compile-time, + * it is set to the \a Dynamic constant. + * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */ + + + SizeAtCompileTime = (internal::size_at_compile_time::RowsAtCompileTime, + internal::traits::ColsAtCompileTime>::ret), + /**< This is equal to the number of coefficients, i.e. the number of + * rows times the number of columns, or to \a Dynamic if this is not + * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */ + + MaxRowsAtCompileTime = internal::traits::MaxRowsAtCompileTime, + /**< This value is equal to the maximum possible number of rows that this expression + * might have. If this expression might have an arbitrarily high number of rows, + * this value is set to \a Dynamic. + * + * This value is useful to know when evaluating an expression, in order to determine + * whether it is possible to avoid doing a dynamic memory allocation. + * + * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime + */ + + MaxColsAtCompileTime = internal::traits::MaxColsAtCompileTime, + /**< This value is equal to the maximum possible number of columns that this expression + * might have. If this expression might have an arbitrarily high number of columns, + * this value is set to \a Dynamic. + * + * This value is useful to know when evaluating an expression, in order to determine + * whether it is possible to avoid doing a dynamic memory allocation. + * + * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime + */ + + MaxSizeAtCompileTime = (internal::size_at_compile_time::MaxRowsAtCompileTime, + internal::traits::MaxColsAtCompileTime>::ret), + /**< This value is equal to the maximum possible number of coefficients that this expression + * might have. If this expression might have an arbitrarily high number of coefficients, + * this value is set to \a Dynamic. + * + * This value is useful to know when evaluating an expression, in order to determine + * whether it is possible to avoid doing a dynamic memory allocation. + * + * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime + */ + + IsVectorAtCompileTime = internal::traits::MaxRowsAtCompileTime == 1 + || internal::traits::MaxColsAtCompileTime == 1, + /**< This is set to true if either the number of rows or the number of + * columns is known at compile-time to be equal to 1. Indeed, in that case, + * we are dealing with a column-vector (if there is only one column) or with + * a row-vector (if there is only one row). */ + + Flags = internal::traits::Flags, + /**< This stores expression \ref flags flags which may or may not be inherited by new expressions + * constructed from this one. See the \ref flags "list of flags". + */ + + IsRowMajor = int(Flags) & RowMajorBit, /**< True if this expression has row-major storage order. */ + + InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime) + : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime), + + InnerStrideAtCompileTime = internal::inner_stride_at_compile_time::ret, + OuterStrideAtCompileTime = internal::outer_stride_at_compile_time::ret + }; + + typedef typename internal::find_best_packet::type PacketScalar; + + enum { IsPlainObjectBase = 0 }; + + /** The plain matrix type corresponding to this expression. + * \sa PlainObject */ + typedef Matrix::Scalar, + internal::traits::RowsAtCompileTime, + internal::traits::ColsAtCompileTime, + AutoAlign | (internal::traits::Flags&RowMajorBit ? RowMajor : ColMajor), + internal::traits::MaxRowsAtCompileTime, + internal::traits::MaxColsAtCompileTime + > PlainMatrix; + + /** The plain array type corresponding to this expression. + * \sa PlainObject */ + typedef Array::Scalar, + internal::traits::RowsAtCompileTime, + internal::traits::ColsAtCompileTime, + AutoAlign | (internal::traits::Flags&RowMajorBit ? RowMajor : ColMajor), + internal::traits::MaxRowsAtCompileTime, + internal::traits::MaxColsAtCompileTime + > PlainArray; + + /** \brief The plain matrix or array type corresponding to this expression. + * + * This is not necessarily exactly the return type of eval(). In the case of plain matrices, + * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed + * that the return type of eval() is either PlainObject or const PlainObject&. + */ + typedef typename internal::conditional::XprKind,MatrixXpr >::value, + PlainMatrix, PlainArray>::type PlainObject; + + /** \returns the number of nonzero coefficients which is in practice the number + * of stored coefficients. */ + EIGEN_DEVICE_FUNC + inline Index nonZeros() const { return size(); } + + /** \returns the outer size. + * + * \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension + * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a + * column-major matrix, and the number of rows for a row-major matrix. */ + EIGEN_DEVICE_FUNC + Index outerSize() const + { + return IsVectorAtCompileTime ? 1 + : int(IsRowMajor) ? this->rows() : this->cols(); + } + + /** \returns the inner size. + * + * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension + * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a + * column-major matrix, and the number of columns for a row-major matrix. */ + EIGEN_DEVICE_FUNC + Index innerSize() const + { + return IsVectorAtCompileTime ? this->size() + : int(IsRowMajor) ? this->cols() : this->rows(); + } + + /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are + * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does + * nothing else. + */ + EIGEN_DEVICE_FUNC + void resize(Index newSize) + { + EIGEN_ONLY_USED_FOR_DEBUG(newSize); + eigen_assert(newSize == this->size() + && "DenseBase::resize() does not actually allow to resize."); + } + /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are + * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does + * nothing else. + */ + EIGEN_DEVICE_FUNC + void resize(Index rows, Index cols) + { + EIGEN_ONLY_USED_FOR_DEBUG(rows); + EIGEN_ONLY_USED_FOR_DEBUG(cols); + eigen_assert(rows == this->rows() && cols == this->cols() + && "DenseBase::resize() does not actually allow to resize."); + } + +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** \internal Represents a matrix with all coefficients equal to one another*/ + typedef CwiseNullaryOp,PlainObject> ConstantReturnType; + /** \internal \deprecated Represents a vector with linearly spaced coefficients that allows sequential access only. */ + typedef CwiseNullaryOp,PlainObject> SequentialLinSpacedReturnType; + /** \internal Represents a vector with linearly spaced coefficients that allows random access. */ + typedef CwiseNullaryOp,PlainObject> RandomAccessLinSpacedReturnType; + /** \internal the return type of MatrixBase::eigenvalues() */ + typedef Matrix::Scalar>::Real, internal::traits::ColsAtCompileTime, 1> EigenvaluesReturnType; + +#endif // not EIGEN_PARSED_BY_DOXYGEN + + /** Copies \a other into *this. \returns a reference to *this. */ + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator=(const DenseBase& other); + + /** Special case of the template operator=, in order to prevent the compiler + * from generating a default operator= (issue hit with g++ 4.1) + */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator=(const DenseBase& other); + + template + EIGEN_DEVICE_FUNC + Derived& operator=(const EigenBase &other); + + template + EIGEN_DEVICE_FUNC + Derived& operator+=(const EigenBase &other); + + template + EIGEN_DEVICE_FUNC + Derived& operator-=(const EigenBase &other); + + template + EIGEN_DEVICE_FUNC + Derived& operator=(const ReturnByValue& func); + + /** \internal + * Copies \a other into *this without evaluating other. \returns a reference to *this. + * \deprecated */ + template + EIGEN_DEVICE_FUNC + Derived& lazyAssign(const DenseBase& other); + + EIGEN_DEVICE_FUNC + CommaInitializer operator<< (const Scalar& s); + + /** \deprecated it now returns \c *this */ + template + EIGEN_DEPRECATED + const Derived& flagged() const + { return derived(); } + + template + EIGEN_DEVICE_FUNC + CommaInitializer operator<< (const DenseBase& other); + + typedef Transpose TransposeReturnType; + EIGEN_DEVICE_FUNC + TransposeReturnType transpose(); + typedef typename internal::add_const >::type ConstTransposeReturnType; + EIGEN_DEVICE_FUNC + ConstTransposeReturnType transpose() const; + EIGEN_DEVICE_FUNC + void transposeInPlace(); + + EIGEN_DEVICE_FUNC static const ConstantReturnType + Constant(Index rows, Index cols, const Scalar& value); + EIGEN_DEVICE_FUNC static const ConstantReturnType + Constant(Index size, const Scalar& value); + EIGEN_DEVICE_FUNC static const ConstantReturnType + Constant(const Scalar& value); + + EIGEN_DEVICE_FUNC static const SequentialLinSpacedReturnType + LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high); + EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType + LinSpaced(Index size, const Scalar& low, const Scalar& high); + EIGEN_DEVICE_FUNC static const SequentialLinSpacedReturnType + LinSpaced(Sequential_t, const Scalar& low, const Scalar& high); + EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType + LinSpaced(const Scalar& low, const Scalar& high); + + template EIGEN_DEVICE_FUNC + static const CwiseNullaryOp + NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func); + template EIGEN_DEVICE_FUNC + static const CwiseNullaryOp + NullaryExpr(Index size, const CustomNullaryOp& func); + template EIGEN_DEVICE_FUNC + static const CwiseNullaryOp + NullaryExpr(const CustomNullaryOp& func); + + EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index rows, Index cols); + EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index size); + EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(); + EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index rows, Index cols); + EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index size); + EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(); + + EIGEN_DEVICE_FUNC void fill(const Scalar& value); + EIGEN_DEVICE_FUNC Derived& setConstant(const Scalar& value); + EIGEN_DEVICE_FUNC Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high); + EIGEN_DEVICE_FUNC Derived& setLinSpaced(const Scalar& low, const Scalar& high); + EIGEN_DEVICE_FUNC Derived& setZero(); + EIGEN_DEVICE_FUNC Derived& setOnes(); + EIGEN_DEVICE_FUNC Derived& setRandom(); + + template EIGEN_DEVICE_FUNC + bool isApprox(const DenseBase& other, + const RealScalar& prec = NumTraits::dummy_precision()) const; + EIGEN_DEVICE_FUNC + bool isMuchSmallerThan(const RealScalar& other, + const RealScalar& prec = NumTraits::dummy_precision()) const; + template EIGEN_DEVICE_FUNC + bool isMuchSmallerThan(const DenseBase& other, + const RealScalar& prec = NumTraits::dummy_precision()) const; + + EIGEN_DEVICE_FUNC bool isApproxToConstant(const Scalar& value, const RealScalar& prec = NumTraits::dummy_precision()) const; + EIGEN_DEVICE_FUNC bool isConstant(const Scalar& value, const RealScalar& prec = NumTraits::dummy_precision()) const; + EIGEN_DEVICE_FUNC bool isZero(const RealScalar& prec = NumTraits::dummy_precision()) const; + EIGEN_DEVICE_FUNC bool isOnes(const RealScalar& prec = NumTraits::dummy_precision()) const; + + inline bool hasNaN() const; + inline bool allFinite() const; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator*=(const Scalar& other); + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator/=(const Scalar& other); + + typedef typename internal::add_const_on_value_type::type>::type EvalReturnType; + /** \returns the matrix or vector obtained by evaluating this expression. + * + * Notice that in the case of a plain matrix or vector (not an expression) this function just returns + * a const reference, in order to avoid a useless copy. + * + * \warning Be carefull with eval() and the auto C++ keyword, as detailed in this \link TopicPitfalls_auto_keyword page \endlink. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE EvalReturnType eval() const + { + // Even though MSVC does not honor strong inlining when the return type + // is a dynamic matrix, we desperately need strong inlining for fixed + // size types on MSVC. + return typename internal::eval::type(derived()); + } + + /** swaps *this with the expression \a other. + * + */ + template + EIGEN_DEVICE_FUNC + void swap(const DenseBase& other) + { + EIGEN_STATIC_ASSERT(!OtherDerived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY); + eigen_assert(rows()==other.rows() && cols()==other.cols()); + call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op()); + } + + /** swaps *this with the matrix or array \a other. + * + */ + template + EIGEN_DEVICE_FUNC + void swap(PlainObjectBase& other) + { + eigen_assert(rows()==other.rows() && cols()==other.cols()); + call_assignment(derived(), other.derived(), internal::swap_assign_op()); + } + + EIGEN_DEVICE_FUNC inline const NestByValue nestByValue() const; + EIGEN_DEVICE_FUNC inline const ForceAlignedAccess forceAlignedAccess() const; + EIGEN_DEVICE_FUNC inline ForceAlignedAccess forceAlignedAccess(); + template EIGEN_DEVICE_FUNC + inline const typename internal::conditional,Derived&>::type forceAlignedAccessIf() const; + template EIGEN_DEVICE_FUNC + inline typename internal::conditional,Derived&>::type forceAlignedAccessIf(); + + EIGEN_DEVICE_FUNC Scalar sum() const; + EIGEN_DEVICE_FUNC Scalar mean() const; + EIGEN_DEVICE_FUNC Scalar trace() const; + + EIGEN_DEVICE_FUNC Scalar prod() const; + + EIGEN_DEVICE_FUNC typename internal::traits::Scalar minCoeff() const; + EIGEN_DEVICE_FUNC typename internal::traits::Scalar maxCoeff() const; + + template EIGEN_DEVICE_FUNC + typename internal::traits::Scalar minCoeff(IndexType* row, IndexType* col) const; + template EIGEN_DEVICE_FUNC + typename internal::traits::Scalar maxCoeff(IndexType* row, IndexType* col) const; + template EIGEN_DEVICE_FUNC + typename internal::traits::Scalar minCoeff(IndexType* index) const; + template EIGEN_DEVICE_FUNC + typename internal::traits::Scalar maxCoeff(IndexType* index) const; + + template + EIGEN_DEVICE_FUNC + Scalar redux(const BinaryOp& func) const; + + template + EIGEN_DEVICE_FUNC + void visit(Visitor& func) const; + + /** \returns a WithFormat proxy object allowing to print a matrix the with given + * format \a fmt. + * + * See class IOFormat for some examples. + * + * \sa class IOFormat, class WithFormat + */ + inline const WithFormat format(const IOFormat& fmt) const + { + return WithFormat(derived(), fmt); + } + + /** \returns the unique coefficient of a 1x1 expression */ + EIGEN_DEVICE_FUNC + CoeffReturnType value() const + { + EIGEN_STATIC_ASSERT_SIZE_1x1(Derived) + eigen_assert(this->rows() == 1 && this->cols() == 1); + return derived().coeff(0,0); + } + + EIGEN_DEVICE_FUNC bool all() const; + EIGEN_DEVICE_FUNC bool any() const; + EIGEN_DEVICE_FUNC Index count() const; + + typedef VectorwiseOp RowwiseReturnType; + typedef const VectorwiseOp ConstRowwiseReturnType; + typedef VectorwiseOp ColwiseReturnType; + typedef const VectorwiseOp ConstColwiseReturnType; + + /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations + * + * Example: \include MatrixBase_rowwise.cpp + * Output: \verbinclude MatrixBase_rowwise.out + * + * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting + */ + //Code moved here due to a CUDA compiler bug + EIGEN_DEVICE_FUNC inline ConstRowwiseReturnType rowwise() const { + return ConstRowwiseReturnType(derived()); + } + EIGEN_DEVICE_FUNC RowwiseReturnType rowwise(); + + /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations + * + * Example: \include MatrixBase_colwise.cpp + * Output: \verbinclude MatrixBase_colwise.out + * + * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting + */ + EIGEN_DEVICE_FUNC inline ConstColwiseReturnType colwise() const { + return ConstColwiseReturnType(derived()); + } + EIGEN_DEVICE_FUNC ColwiseReturnType colwise(); + + typedef CwiseNullaryOp,PlainObject> RandomReturnType; + static const RandomReturnType Random(Index rows, Index cols); + static const RandomReturnType Random(Index size); + static const RandomReturnType Random(); + + template + const Select + select(const DenseBase& thenMatrix, + const DenseBase& elseMatrix) const; + + template + inline const Select + select(const DenseBase& thenMatrix, const typename ThenDerived::Scalar& elseScalar) const; + + template + inline const Select + select(const typename ElseDerived::Scalar& thenScalar, const DenseBase& elseMatrix) const; + + template RealScalar lpNorm() const; + + template + EIGEN_DEVICE_FUNC + const Replicate replicate() const; + /** + * \return an expression of the replication of \c *this + * + * Example: \include MatrixBase_replicate_int_int.cpp + * Output: \verbinclude MatrixBase_replicate_int_int.out + * + * \sa VectorwiseOp::replicate(), DenseBase::replicate(), class Replicate + */ + //Code moved here due to a CUDA compiler bug + EIGEN_DEVICE_FUNC + const Replicate replicate(Index rowFactor, Index colFactor) const + { + return Replicate(derived(), rowFactor, colFactor); + } + + typedef Reverse ReverseReturnType; + typedef const Reverse ConstReverseReturnType; + EIGEN_DEVICE_FUNC ReverseReturnType reverse(); + /** This is the const version of reverse(). */ + //Code moved here due to a CUDA compiler bug + EIGEN_DEVICE_FUNC ConstReverseReturnType reverse() const + { + return ConstReverseReturnType(derived()); + } + EIGEN_DEVICE_FUNC void reverseInPlace(); + +#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase +#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL +#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND) +# include "../plugins/BlockMethods.h" +# ifdef EIGEN_DENSEBASE_PLUGIN +# include EIGEN_DENSEBASE_PLUGIN +# endif +#undef EIGEN_CURRENT_STORAGE_BASE_CLASS +#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL +#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF + + // disable the use of evalTo for dense objects with a nice compilation error + template + EIGEN_DEVICE_FUNC + inline void evalTo(Dest& ) const + { + EIGEN_STATIC_ASSERT((internal::is_same::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS); + } + + protected: + /** Default constructor. Do nothing. */ + EIGEN_DEVICE_FUNC DenseBase() + { + /* Just checks for self-consistency of the flags. + * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down + */ +#ifdef EIGEN_INTERNAL_DEBUGGING + EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor)) + && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))), + INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION) +#endif + } + + private: + EIGEN_DEVICE_FUNC explicit DenseBase(int); + EIGEN_DEVICE_FUNC DenseBase(int,int); + template EIGEN_DEVICE_FUNC explicit DenseBase(const DenseBase&); +}; + +} // end namespace Eigen + +#endif // EIGEN_DENSEBASE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/DenseCoeffsBase.h b/3rdparty/eigen3/Eigen/src/Core/DenseCoeffsBase.h new file mode 100644 index 0000000..c4af48a --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/DenseCoeffsBase.h @@ -0,0 +1,681 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2010 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_DENSECOEFFSBASE_H +#define EIGEN_DENSECOEFFSBASE_H + +namespace Eigen { + +namespace internal { +template struct add_const_on_value_type_if_arithmetic +{ + typedef typename conditional::value, T, typename add_const_on_value_type::type>::type type; +}; +} + +/** \brief Base class providing read-only coefficient access to matrices and arrays. + * \ingroup Core_Module + * \tparam Derived Type of the derived class + * \tparam #ReadOnlyAccessors Constant indicating read-only access + * + * This class defines the \c operator() \c const function and friends, which can be used to read specific + * entries of a matrix or array. + * + * \sa DenseCoeffsBase, DenseCoeffsBase, + * \ref TopicClassHierarchy + */ +template +class DenseCoeffsBase : public EigenBase +{ + public: + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; + + // Explanation for this CoeffReturnType typedef. + // - This is the return type of the coeff() method. + // - The LvalueBit means exactly that we can offer a coeffRef() method, which means exactly that we can get references + // to coeffs, which means exactly that we can have coeff() return a const reference (as opposed to returning a value). + // - The is_artihmetic check is required since "const int", "const double", etc. will cause warnings on some systems + // while the declaration of "const T", where T is a non arithmetic type does not. Always returning "const Scalar&" is + // not possible, since the underlying expressions might not offer a valid address the reference could be referring to. + typedef typename internal::conditional::Flags&LvalueBit), + const Scalar&, + typename internal::conditional::value, Scalar, const Scalar>::type + >::type CoeffReturnType; + + typedef typename internal::add_const_on_value_type_if_arithmetic< + typename internal::packet_traits::type + >::type PacketReturnType; + + typedef EigenBase Base; + using Base::rows; + using Base::cols; + using Base::size; + using Base::derived; + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const + { + return int(Derived::RowsAtCompileTime) == 1 ? 0 + : int(Derived::ColsAtCompileTime) == 1 ? inner + : int(Derived::Flags)&RowMajorBit ? outer + : inner; + } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const + { + return int(Derived::ColsAtCompileTime) == 1 ? 0 + : int(Derived::RowsAtCompileTime) == 1 ? inner + : int(Derived::Flags)&RowMajorBit ? inner + : outer; + } + + /** Short version: don't use this function, use + * \link operator()(Index,Index) const \endlink instead. + * + * Long version: this function is similar to + * \link operator()(Index,Index) const \endlink, but without the assertion. + * Use this for limiting the performance cost of debugging code when doing + * repeated coefficient access. Only use this when it is guaranteed that the + * parameters \a row and \a col are in range. + * + * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this + * function equivalent to \link operator()(Index,Index) const \endlink. + * + * \sa operator()(Index,Index) const, coeffRef(Index,Index), coeff(Index) const + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const + { + eigen_internal_assert(row >= 0 && row < rows() + && col >= 0 && col < cols()); + return internal::evaluator(derived()).coeff(row,col); + } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const + { + return coeff(rowIndexByOuterInner(outer, inner), + colIndexByOuterInner(outer, inner)); + } + + /** \returns the coefficient at given the given row and column. + * + * \sa operator()(Index,Index), operator[](Index) + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const + { + eigen_assert(row >= 0 && row < rows() + && col >= 0 && col < cols()); + return coeff(row, col); + } + + /** Short version: don't use this function, use + * \link operator[](Index) const \endlink instead. + * + * Long version: this function is similar to + * \link operator[](Index) const \endlink, but without the assertion. + * Use this for limiting the performance cost of debugging code when doing + * repeated coefficient access. Only use this when it is guaranteed that the + * parameter \a index is in range. + * + * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this + * function equivalent to \link operator[](Index) const \endlink. + * + * \sa operator[](Index) const, coeffRef(Index), coeff(Index,Index) const + */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType + coeff(Index index) const + { + EIGEN_STATIC_ASSERT(internal::evaluator::Flags & LinearAccessBit, + THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS) + eigen_internal_assert(index >= 0 && index < size()); + return internal::evaluator(derived()).coeff(index); + } + + + /** \returns the coefficient at given index. + * + * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit. + * + * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const, + * z() const, w() const + */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType + operator[](Index index) const + { + EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime, + THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD) + eigen_assert(index >= 0 && index < size()); + return coeff(index); + } + + /** \returns the coefficient at given index. + * + * This is synonymous to operator[](Index) const. + * + * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit. + * + * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const, + * z() const, w() const + */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType + operator()(Index index) const + { + eigen_assert(index >= 0 && index < size()); + return coeff(index); + } + + /** equivalent to operator[](0). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType + x() const { return (*this)[0]; } + + /** equivalent to operator[](1). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType + y() const + { + EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS); + return (*this)[1]; + } + + /** equivalent to operator[](2). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType + z() const + { + EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS); + return (*this)[2]; + } + + /** equivalent to operator[](3). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE CoeffReturnType + w() const + { + EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS); + return (*this)[3]; + } + + /** \internal + * \returns the packet of coefficients starting at the given row and column. It is your responsibility + * to ensure that a packet really starts there. This method is only available on expressions having the + * PacketAccessBit. + * + * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select + * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets + * starting at an address which is a multiple of the packet size. + */ + + template + EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const + { + typedef typename internal::packet_traits::type DefaultPacketType; + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); + return internal::evaluator(derived()).template packet(row,col); + } + + + /** \internal */ + template + EIGEN_STRONG_INLINE PacketReturnType packetByOuterInner(Index outer, Index inner) const + { + return packet(rowIndexByOuterInner(outer, inner), + colIndexByOuterInner(outer, inner)); + } + + /** \internal + * \returns the packet of coefficients starting at the given index. It is your responsibility + * to ensure that a packet really starts there. This method is only available on expressions having the + * PacketAccessBit and the LinearAccessBit. + * + * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select + * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets + * starting at an address which is a multiple of the packet size. + */ + + template + EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const + { + EIGEN_STATIC_ASSERT(internal::evaluator::Flags & LinearAccessBit, + THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS) + typedef typename internal::packet_traits::type DefaultPacketType; + eigen_internal_assert(index >= 0 && index < size()); + return internal::evaluator(derived()).template packet(index); + } + + protected: + // explanation: DenseBase is doing "using ..." on the methods from DenseCoeffsBase. + // But some methods are only available in the DirectAccess case. + // So we add dummy methods here with these names, so that "using... " doesn't fail. + // It's not private so that the child class DenseBase can access them, and it's not public + // either since it's an implementation detail, so has to be protected. + void coeffRef(); + void coeffRefByOuterInner(); + void writePacket(); + void writePacketByOuterInner(); + void copyCoeff(); + void copyCoeffByOuterInner(); + void copyPacket(); + void copyPacketByOuterInner(); + void stride(); + void innerStride(); + void outerStride(); + void rowStride(); + void colStride(); +}; + +/** \brief Base class providing read/write coefficient access to matrices and arrays. + * \ingroup Core_Module + * \tparam Derived Type of the derived class + * \tparam #WriteAccessors Constant indicating read/write access + * + * This class defines the non-const \c operator() function and friends, which can be used to write specific + * entries of a matrix or array. This class inherits DenseCoeffsBase which + * defines the const variant for reading specific entries. + * + * \sa DenseCoeffsBase, \ref TopicClassHierarchy + */ +template +class DenseCoeffsBase : public DenseCoeffsBase +{ + public: + + typedef DenseCoeffsBase Base; + + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; + typedef typename NumTraits::Real RealScalar; + + using Base::coeff; + using Base::rows; + using Base::cols; + using Base::size; + using Base::derived; + using Base::rowIndexByOuterInner; + using Base::colIndexByOuterInner; + using Base::operator[]; + using Base::operator(); + using Base::x; + using Base::y; + using Base::z; + using Base::w; + + /** Short version: don't use this function, use + * \link operator()(Index,Index) \endlink instead. + * + * Long version: this function is similar to + * \link operator()(Index,Index) \endlink, but without the assertion. + * Use this for limiting the performance cost of debugging code when doing + * repeated coefficient access. Only use this when it is guaranteed that the + * parameters \a row and \a col are in range. + * + * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this + * function equivalent to \link operator()(Index,Index) \endlink. + * + * \sa operator()(Index,Index), coeff(Index, Index) const, coeffRef(Index) + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col) + { + eigen_internal_assert(row >= 0 && row < rows() + && col >= 0 && col < cols()); + return internal::evaluator(derived()).coeffRef(row,col); + } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + coeffRefByOuterInner(Index outer, Index inner) + { + return coeffRef(rowIndexByOuterInner(outer, inner), + colIndexByOuterInner(outer, inner)); + } + + /** \returns a reference to the coefficient at given the given row and column. + * + * \sa operator[](Index) + */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + operator()(Index row, Index col) + { + eigen_assert(row >= 0 && row < rows() + && col >= 0 && col < cols()); + return coeffRef(row, col); + } + + + /** Short version: don't use this function, use + * \link operator[](Index) \endlink instead. + * + * Long version: this function is similar to + * \link operator[](Index) \endlink, but without the assertion. + * Use this for limiting the performance cost of debugging code when doing + * repeated coefficient access. Only use this when it is guaranteed that the + * parameters \a row and \a col are in range. + * + * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this + * function equivalent to \link operator[](Index) \endlink. + * + * \sa operator[](Index), coeff(Index) const, coeffRef(Index,Index) + */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + coeffRef(Index index) + { + EIGEN_STATIC_ASSERT(internal::evaluator::Flags & LinearAccessBit, + THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS) + eigen_internal_assert(index >= 0 && index < size()); + return internal::evaluator(derived()).coeffRef(index); + } + + /** \returns a reference to the coefficient at given index. + * + * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit. + * + * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w() + */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + operator[](Index index) + { + EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime, + THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD) + eigen_assert(index >= 0 && index < size()); + return coeffRef(index); + } + + /** \returns a reference to the coefficient at given index. + * + * This is synonymous to operator[](Index). + * + * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit. + * + * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w() + */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + operator()(Index index) + { + eigen_assert(index >= 0 && index < size()); + return coeffRef(index); + } + + /** equivalent to operator[](0). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + x() { return (*this)[0]; } + + /** equivalent to operator[](1). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + y() + { + EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS); + return (*this)[1]; + } + + /** equivalent to operator[](2). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + z() + { + EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS); + return (*this)[2]; + } + + /** equivalent to operator[](3). */ + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& + w() + { + EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS); + return (*this)[3]; + } +}; + +/** \brief Base class providing direct read-only coefficient access to matrices and arrays. + * \ingroup Core_Module + * \tparam Derived Type of the derived class + * \tparam #DirectAccessors Constant indicating direct access + * + * This class defines functions to work with strides which can be used to access entries directly. This class + * inherits DenseCoeffsBase which defines functions to access entries read-only using + * \c operator() . + * + * \sa \blank \ref TopicClassHierarchy + */ +template +class DenseCoeffsBase : public DenseCoeffsBase +{ + public: + + typedef DenseCoeffsBase Base; + typedef typename internal::traits::Scalar Scalar; + typedef typename NumTraits::Real RealScalar; + + using Base::rows; + using Base::cols; + using Base::size; + using Base::derived; + + /** \returns the pointer increment between two consecutive elements within a slice in the inner direction. + * + * \sa outerStride(), rowStride(), colStride() + */ + EIGEN_DEVICE_FUNC + inline Index innerStride() const + { + return derived().innerStride(); + } + + /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns + * in a column-major matrix). + * + * \sa innerStride(), rowStride(), colStride() + */ + EIGEN_DEVICE_FUNC + inline Index outerStride() const + { + return derived().outerStride(); + } + + // FIXME shall we remove it ? + inline Index stride() const + { + return Derived::IsVectorAtCompileTime ? innerStride() : outerStride(); + } + + /** \returns the pointer increment between two consecutive rows. + * + * \sa innerStride(), outerStride(), colStride() + */ + EIGEN_DEVICE_FUNC + inline Index rowStride() const + { + return Derived::IsRowMajor ? outerStride() : innerStride(); + } + + /** \returns the pointer increment between two consecutive columns. + * + * \sa innerStride(), outerStride(), rowStride() + */ + EIGEN_DEVICE_FUNC + inline Index colStride() const + { + return Derived::IsRowMajor ? innerStride() : outerStride(); + } +}; + +/** \brief Base class providing direct read/write coefficient access to matrices and arrays. + * \ingroup Core_Module + * \tparam Derived Type of the derived class + * \tparam #DirectWriteAccessors Constant indicating direct access + * + * This class defines functions to work with strides which can be used to access entries directly. This class + * inherits DenseCoeffsBase which defines functions to access entries read/write using + * \c operator(). + * + * \sa \blank \ref TopicClassHierarchy + */ +template +class DenseCoeffsBase + : public DenseCoeffsBase +{ + public: + + typedef DenseCoeffsBase Base; + typedef typename internal::traits::Scalar Scalar; + typedef typename NumTraits::Real RealScalar; + + using Base::rows; + using Base::cols; + using Base::size; + using Base::derived; + + /** \returns the pointer increment between two consecutive elements within a slice in the inner direction. + * + * \sa outerStride(), rowStride(), colStride() + */ + EIGEN_DEVICE_FUNC + inline Index innerStride() const + { + return derived().innerStride(); + } + + /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns + * in a column-major matrix). + * + * \sa innerStride(), rowStride(), colStride() + */ + EIGEN_DEVICE_FUNC + inline Index outerStride() const + { + return derived().outerStride(); + } + + // FIXME shall we remove it ? + inline Index stride() const + { + return Derived::IsVectorAtCompileTime ? innerStride() : outerStride(); + } + + /** \returns the pointer increment between two consecutive rows. + * + * \sa innerStride(), outerStride(), colStride() + */ + EIGEN_DEVICE_FUNC + inline Index rowStride() const + { + return Derived::IsRowMajor ? outerStride() : innerStride(); + } + + /** \returns the pointer increment between two consecutive columns. + * + * \sa innerStride(), outerStride(), rowStride() + */ + EIGEN_DEVICE_FUNC + inline Index colStride() const + { + return Derived::IsRowMajor ? innerStride() : outerStride(); + } +}; + +namespace internal { + +template +struct first_aligned_impl +{ + static inline Index run(const Derived&) + { return 0; } +}; + +template +struct first_aligned_impl +{ + static inline Index run(const Derived& m) + { + return internal::first_aligned(m.data(), m.size()); + } +}; + +/** \internal \returns the index of the first element of the array stored by \a m that is properly aligned with respect to \a Alignment for vectorization. + * + * \tparam Alignment requested alignment in Bytes. + * + * There is also the variant first_aligned(const Scalar*, Integer) defined in Memory.h. See it for more + * documentation. + */ +template +static inline Index first_aligned(const DenseBase& m) +{ + enum { ReturnZero = (int(evaluator::Alignment) >= Alignment) || !(Derived::Flags & DirectAccessBit) }; + return first_aligned_impl::run(m.derived()); +} + +template +static inline Index first_default_aligned(const DenseBase& m) +{ + typedef typename Derived::Scalar Scalar; + typedef typename packet_traits::type DefaultPacketType; + return internal::first_aligned::alignment),Derived>(m); +} + +template::ret> +struct inner_stride_at_compile_time +{ + enum { ret = traits::InnerStrideAtCompileTime }; +}; + +template +struct inner_stride_at_compile_time +{ + enum { ret = 0 }; +}; + +template::ret> +struct outer_stride_at_compile_time +{ + enum { ret = traits::OuterStrideAtCompileTime }; +}; + +template +struct outer_stride_at_compile_time +{ + enum { ret = 0 }; +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_DENSECOEFFSBASE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/DenseStorage.h b/3rdparty/eigen3/Eigen/src/Core/DenseStorage.h new file mode 100644 index 0000000..7958fee --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/DenseStorage.h @@ -0,0 +1,570 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2006-2009 Benoit Jacob +// Copyright (C) 2010-2013 Hauke Heibel +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_MATRIXSTORAGE_H +#define EIGEN_MATRIXSTORAGE_H + +#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X) X; EIGEN_DENSE_STORAGE_CTOR_PLUGIN; +#else + #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X) +#endif + +namespace Eigen { + +namespace internal { + +struct constructor_without_unaligned_array_assert {}; + +template +EIGEN_DEVICE_FUNC +void check_static_allocation_size() +{ + // if EIGEN_STACK_ALLOCATION_LIMIT is defined to 0, then no limit + #if EIGEN_STACK_ALLOCATION_LIMIT + EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG); + #endif +} + +/** \internal + * Static array. If the MatrixOrArrayOptions require auto-alignment, the array will be automatically aligned: + * to 16 bytes boundary if the total size is a multiple of 16 bytes. + */ +template ::value > +struct plain_array +{ + T array[Size]; + + EIGEN_DEVICE_FUNC + plain_array() + { + check_static_allocation_size(); + } + + EIGEN_DEVICE_FUNC + plain_array(constructor_without_unaligned_array_assert) + { + check_static_allocation_size(); + } +}; + +#if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT) + #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) +#elif EIGEN_GNUC_AT_LEAST(4,7) + // GCC 4.7 is too aggressive in its optimizations and remove the alignement test based on the fact the array is declared to be aligned. + // See this bug report: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53900 + // Hiding the origin of the array pointer behind a function argument seems to do the trick even if the function is inlined: + template + EIGEN_ALWAYS_INLINE PtrType eigen_unaligned_array_assert_workaround_gcc47(PtrType array) { return array; } + #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \ + eigen_assert((internal::UIntPtr(eigen_unaligned_array_assert_workaround_gcc47(array)) & (sizemask)) == 0 \ + && "this assertion is explained here: " \ + "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \ + " **** READ THIS WEB PAGE !!! ****"); +#else + #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \ + eigen_assert((internal::UIntPtr(array) & (sizemask)) == 0 \ + && "this assertion is explained here: " \ + "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \ + " **** READ THIS WEB PAGE !!! ****"); +#endif + +template +struct plain_array +{ + EIGEN_ALIGN_TO_BOUNDARY(8) T array[Size]; + + EIGEN_DEVICE_FUNC + plain_array() + { + EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(7); + check_static_allocation_size(); + } + + EIGEN_DEVICE_FUNC + plain_array(constructor_without_unaligned_array_assert) + { + check_static_allocation_size(); + } +}; + +template +struct plain_array +{ + EIGEN_ALIGN_TO_BOUNDARY(16) T array[Size]; + + EIGEN_DEVICE_FUNC + plain_array() + { + EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(15); + check_static_allocation_size(); + } + + EIGEN_DEVICE_FUNC + plain_array(constructor_without_unaligned_array_assert) + { + check_static_allocation_size(); + } +}; + +template +struct plain_array +{ + EIGEN_ALIGN_TO_BOUNDARY(32) T array[Size]; + + EIGEN_DEVICE_FUNC + plain_array() + { + EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(31); + check_static_allocation_size(); + } + + EIGEN_DEVICE_FUNC + plain_array(constructor_without_unaligned_array_assert) + { + check_static_allocation_size(); + } +}; + +template +struct plain_array +{ + EIGEN_ALIGN_TO_BOUNDARY(64) T array[Size]; + + EIGEN_DEVICE_FUNC + plain_array() + { + EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(63); + check_static_allocation_size(); + } + + EIGEN_DEVICE_FUNC + plain_array(constructor_without_unaligned_array_assert) + { + check_static_allocation_size(); + } +}; + +template +struct plain_array +{ + T array[1]; + EIGEN_DEVICE_FUNC plain_array() {} + EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert) {} +}; + +} // end namespace internal + +/** \internal + * + * \class DenseStorage + * \ingroup Core_Module + * + * \brief Stores the data of a matrix + * + * This class stores the data of fixed-size, dynamic-size or mixed matrices + * in a way as compact as possible. + * + * \sa Matrix + */ +template class DenseStorage; + +// purely fixed-size matrix +template class DenseStorage +{ + internal::plain_array m_data; + public: + EIGEN_DEVICE_FUNC DenseStorage() { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size) + } + EIGEN_DEVICE_FUNC + explicit DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()) {} + EIGEN_DEVICE_FUNC + DenseStorage(const DenseStorage& other) : m_data(other.m_data) { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size) + } + EIGEN_DEVICE_FUNC + DenseStorage& operator=(const DenseStorage& other) + { + if (this != &other) m_data = other.m_data; + return *this; + } + EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + eigen_internal_assert(size==rows*cols && rows==_Rows && cols==_Cols); + EIGEN_UNUSED_VARIABLE(size); + EIGEN_UNUSED_VARIABLE(rows); + EIGEN_UNUSED_VARIABLE(cols); + } + EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); } + EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;} + EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;} + EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {} + EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {} + EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; } + EIGEN_DEVICE_FUNC T *data() { return m_data.array; } +}; + +// null matrix +template class DenseStorage +{ + public: + EIGEN_DEVICE_FUNC DenseStorage() {} + EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) {} + EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {} + EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) { return *this; } + EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {} + EIGEN_DEVICE_FUNC void swap(DenseStorage& ) {} + EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;} + EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;} + EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {} + EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {} + EIGEN_DEVICE_FUNC const T *data() const { return 0; } + EIGEN_DEVICE_FUNC T *data() { return 0; } +}; + +// more specializations for null matrices; these are necessary to resolve ambiguities +template class DenseStorage +: public DenseStorage { }; + +template class DenseStorage +: public DenseStorage { }; + +template class DenseStorage +: public DenseStorage { }; + +// dynamic-size matrix with fixed-size storage +template class DenseStorage +{ + internal::plain_array m_data; + Index m_rows; + Index m_cols; + public: + EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {} + EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {} + EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows), m_cols(other.m_cols) {} + EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) + { + if (this != &other) + { + m_data = other.m_data; + m_rows = other.m_rows; + m_cols = other.m_cols; + } + return *this; + } + EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) {} + EIGEN_DEVICE_FUNC void swap(DenseStorage& other) + { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); } + EIGEN_DEVICE_FUNC Index rows() const {return m_rows;} + EIGEN_DEVICE_FUNC Index cols() const {return m_cols;} + EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; } + EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; } + EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; } + EIGEN_DEVICE_FUNC T *data() { return m_data.array; } +}; + +// dynamic-size matrix with fixed-size storage and fixed width +template class DenseStorage +{ + internal::plain_array m_data; + Index m_rows; + public: + EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {} + EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {} + EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows) {} + EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) + { + if (this != &other) + { + m_data = other.m_data; + m_rows = other.m_rows; + } + return *this; + } + EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {} + EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); } + EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;} + EIGEN_DEVICE_FUNC Index cols(void) const {return _Cols;} + EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_rows = rows; } + EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; } + EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; } + EIGEN_DEVICE_FUNC T *data() { return m_data.array; } +}; + +// dynamic-size matrix with fixed-size storage and fixed height +template class DenseStorage +{ + internal::plain_array m_data; + Index m_cols; + public: + EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {} + EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {} + EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_cols(other.m_cols) {} + EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) + { + if (this != &other) + { + m_data = other.m_data; + m_cols = other.m_cols; + } + return *this; + } + EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {} + EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); } + EIGEN_DEVICE_FUNC Index rows(void) const {return _Rows;} + EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;} + void conservativeResize(Index, Index, Index cols) { m_cols = cols; } + void resize(Index, Index, Index cols) { m_cols = cols; } + EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; } + EIGEN_DEVICE_FUNC T *data() { return m_data.array; } +}; + +// purely dynamic matrix. +template class DenseStorage +{ + T *m_data; + Index m_rows; + Index m_cols; + public: + EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0), m_cols(0) {} + EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(0), m_rows(0), m_cols(0) {} + EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) + : m_data(internal::conditional_aligned_new_auto(size)), m_rows(rows), m_cols(cols) + { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + eigen_internal_assert(size==rows*cols && rows>=0 && cols >=0); + } + EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) + : m_data(internal::conditional_aligned_new_auto(other.m_rows*other.m_cols)) + , m_rows(other.m_rows) + , m_cols(other.m_cols) + { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*m_cols) + internal::smart_copy(other.m_data, other.m_data+other.m_rows*other.m_cols, m_data); + } + EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) + { + if (this != &other) + { + DenseStorage tmp(other); + this->swap(tmp); + } + return *this; + } +#if EIGEN_HAS_RVALUE_REFERENCES + EIGEN_DEVICE_FUNC + DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT + : m_data(std::move(other.m_data)) + , m_rows(std::move(other.m_rows)) + , m_cols(std::move(other.m_cols)) + { + other.m_data = nullptr; + other.m_rows = 0; + other.m_cols = 0; + } + EIGEN_DEVICE_FUNC + DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT + { + using std::swap; + swap(m_data, other.m_data); + swap(m_rows, other.m_rows); + swap(m_cols, other.m_cols); + return *this; + } +#endif + EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto(m_data, m_rows*m_cols); } + EIGEN_DEVICE_FUNC void swap(DenseStorage& other) + { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); } + EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;} + EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;} + void conservativeResize(Index size, Index rows, Index cols) + { + m_data = internal::conditional_aligned_realloc_new_auto(m_data, size, m_rows*m_cols); + m_rows = rows; + m_cols = cols; + } + EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols) + { + if(size != m_rows*m_cols) + { + internal::conditional_aligned_delete_auto(m_data, m_rows*m_cols); + if (size) + m_data = internal::conditional_aligned_new_auto(size); + else + m_data = 0; + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + } + m_rows = rows; + m_cols = cols; + } + EIGEN_DEVICE_FUNC const T *data() const { return m_data; } + EIGEN_DEVICE_FUNC T *data() { return m_data; } +}; + +// matrix with dynamic width and fixed height (so that matrix has dynamic size). +template class DenseStorage +{ + T *m_data; + Index m_cols; + public: + EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_cols(0) {} + explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {} + EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto(size)), m_cols(cols) + { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + eigen_internal_assert(size==rows*cols && rows==_Rows && cols >=0); + EIGEN_UNUSED_VARIABLE(rows); + } + EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) + : m_data(internal::conditional_aligned_new_auto(_Rows*other.m_cols)) + , m_cols(other.m_cols) + { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_cols*_Rows) + internal::smart_copy(other.m_data, other.m_data+_Rows*m_cols, m_data); + } + EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) + { + if (this != &other) + { + DenseStorage tmp(other); + this->swap(tmp); + } + return *this; + } +#if EIGEN_HAS_RVALUE_REFERENCES + EIGEN_DEVICE_FUNC + DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT + : m_data(std::move(other.m_data)) + , m_cols(std::move(other.m_cols)) + { + other.m_data = nullptr; + other.m_cols = 0; + } + EIGEN_DEVICE_FUNC + DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT + { + using std::swap; + swap(m_data, other.m_data); + swap(m_cols, other.m_cols); + return *this; + } +#endif + EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto(m_data, _Rows*m_cols); } + EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); } + EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;} + EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;} + EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols) + { + m_data = internal::conditional_aligned_realloc_new_auto(m_data, size, _Rows*m_cols); + m_cols = cols; + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols) + { + if(size != _Rows*m_cols) + { + internal::conditional_aligned_delete_auto(m_data, _Rows*m_cols); + if (size) + m_data = internal::conditional_aligned_new_auto(size); + else + m_data = 0; + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + } + m_cols = cols; + } + EIGEN_DEVICE_FUNC const T *data() const { return m_data; } + EIGEN_DEVICE_FUNC T *data() { return m_data; } +}; + +// matrix with dynamic height and fixed width (so that matrix has dynamic size). +template class DenseStorage +{ + T *m_data; + Index m_rows; + public: + EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0) {} + explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {} + EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto(size)), m_rows(rows) + { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + eigen_internal_assert(size==rows*cols && rows>=0 && cols == _Cols); + EIGEN_UNUSED_VARIABLE(cols); + } + EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) + : m_data(internal::conditional_aligned_new_auto(other.m_rows*_Cols)) + , m_rows(other.m_rows) + { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*_Cols) + internal::smart_copy(other.m_data, other.m_data+other.m_rows*_Cols, m_data); + } + EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) + { + if (this != &other) + { + DenseStorage tmp(other); + this->swap(tmp); + } + return *this; + } +#if EIGEN_HAS_RVALUE_REFERENCES + EIGEN_DEVICE_FUNC + DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT + : m_data(std::move(other.m_data)) + , m_rows(std::move(other.m_rows)) + { + other.m_data = nullptr; + other.m_rows = 0; + } + EIGEN_DEVICE_FUNC + DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT + { + using std::swap; + swap(m_data, other.m_data); + swap(m_rows, other.m_rows); + return *this; + } +#endif + EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto(m_data, _Cols*m_rows); } + EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); } + EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;} + EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;} + void conservativeResize(Index size, Index rows, Index) + { + m_data = internal::conditional_aligned_realloc_new_auto(m_data, size, m_rows*_Cols); + m_rows = rows; + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index) + { + if(size != m_rows*_Cols) + { + internal::conditional_aligned_delete_auto(m_data, _Cols*m_rows); + if (size) + m_data = internal::conditional_aligned_new_auto(size); + else + m_data = 0; + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + } + m_rows = rows; + } + EIGEN_DEVICE_FUNC const T *data() const { return m_data; } + EIGEN_DEVICE_FUNC T *data() { return m_data; } +}; + +} // end namespace Eigen + +#endif // EIGEN_MATRIX_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Diagonal.h b/3rdparty/eigen3/Eigen/src/Core/Diagonal.h new file mode 100644 index 0000000..afcaf35 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Diagonal.h @@ -0,0 +1,260 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2007-2009 Benoit Jacob +// Copyright (C) 2009-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_DIAGONAL_H +#define EIGEN_DIAGONAL_H + +namespace Eigen { + +/** \class Diagonal + * \ingroup Core_Module + * + * \brief Expression of a diagonal/subdiagonal/superdiagonal in a matrix + * + * \param MatrixType the type of the object in which we are taking a sub/main/super diagonal + * \param DiagIndex the index of the sub/super diagonal. The default is 0 and it means the main diagonal. + * A positive value means a superdiagonal, a negative value means a subdiagonal. + * You can also use DynamicIndex so the index can be set at runtime. + * + * The matrix is not required to be square. + * + * This class represents an expression of the main diagonal, or any sub/super diagonal + * of a square matrix. It is the return type of MatrixBase::diagonal() and MatrixBase::diagonal(Index) and most of the + * time this is the only way it is used. + * + * \sa MatrixBase::diagonal(), MatrixBase::diagonal(Index) + */ + +namespace internal { +template +struct traits > + : traits +{ + typedef typename ref_selector::type MatrixTypeNested; + typedef typename remove_reference::type _MatrixTypeNested; + typedef typename MatrixType::StorageKind StorageKind; + enum { + RowsAtCompileTime = (int(DiagIndex) == DynamicIndex || int(MatrixType::SizeAtCompileTime) == Dynamic) ? Dynamic + : (EIGEN_PLAIN_ENUM_MIN(MatrixType::RowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0), + MatrixType::ColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))), + ColsAtCompileTime = 1, + MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic + : DiagIndex == DynamicIndex ? EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::MaxRowsAtCompileTime, + MatrixType::MaxColsAtCompileTime) + : (EIGEN_PLAIN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0), + MatrixType::MaxColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))), + MaxColsAtCompileTime = 1, + MaskLvalueBit = is_lvalue::value ? LvalueBit : 0, + Flags = (unsigned int)_MatrixTypeNested::Flags & (RowMajorBit | MaskLvalueBit | DirectAccessBit) & ~RowMajorBit, // FIXME DirectAccessBit should not be handled by expressions + MatrixTypeOuterStride = outer_stride_at_compile_time::ret, + InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride+1, + OuterStrideAtCompileTime = 0 + }; +}; +} + +template class Diagonal + : public internal::dense_xpr_base< Diagonal >::type +{ + public: + + enum { DiagIndex = _DiagIndex }; + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal) + + EIGEN_DEVICE_FUNC + explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) : m_matrix(matrix), m_index(a_index) + { + eigen_assert( a_index <= m_matrix.cols() && -a_index <= m_matrix.rows() ); + } + + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal) + + EIGEN_DEVICE_FUNC + inline Index rows() const + { + return m_index.value()<0 ? numext::mini(m_matrix.cols(),m_matrix.rows()+m_index.value()) + : numext::mini(m_matrix.rows(),m_matrix.cols()-m_index.value()); + } + + EIGEN_DEVICE_FUNC + inline Index cols() const { return 1; } + + EIGEN_DEVICE_FUNC + inline Index innerStride() const + { + return m_matrix.outerStride() + 1; + } + + EIGEN_DEVICE_FUNC + inline Index outerStride() const + { + return 0; + } + + typedef typename internal::conditional< + internal::is_lvalue::value, + Scalar, + const Scalar + >::type ScalarWithConstIfNotLvalue; + + EIGEN_DEVICE_FUNC + inline ScalarWithConstIfNotLvalue* data() { return &(m_matrix.coeffRef(rowOffset(), colOffset())); } + EIGEN_DEVICE_FUNC + inline const Scalar* data() const { return &(m_matrix.coeffRef(rowOffset(), colOffset())); } + + EIGEN_DEVICE_FUNC + inline Scalar& coeffRef(Index row, Index) + { + EIGEN_STATIC_ASSERT_LVALUE(MatrixType) + return m_matrix.coeffRef(row+rowOffset(), row+colOffset()); + } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index row, Index) const + { + return m_matrix.coeffRef(row+rowOffset(), row+colOffset()); + } + + EIGEN_DEVICE_FUNC + inline CoeffReturnType coeff(Index row, Index) const + { + return m_matrix.coeff(row+rowOffset(), row+colOffset()); + } + + EIGEN_DEVICE_FUNC + inline Scalar& coeffRef(Index idx) + { + EIGEN_STATIC_ASSERT_LVALUE(MatrixType) + return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset()); + } + + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index idx) const + { + return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset()); + } + + EIGEN_DEVICE_FUNC + inline CoeffReturnType coeff(Index idx) const + { + return m_matrix.coeff(idx+rowOffset(), idx+colOffset()); + } + + EIGEN_DEVICE_FUNC + inline const typename internal::remove_all::type& + nestedExpression() const + { + return m_matrix; + } + + EIGEN_DEVICE_FUNC + inline Index index() const + { + return m_index.value(); + } + + protected: + typename internal::ref_selector::non_const_type m_matrix; + const internal::variable_if_dynamicindex m_index; + + private: + // some compilers may fail to optimize std::max etc in case of compile-time constants... + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index absDiagIndex() const { return m_index.value()>0 ? m_index.value() : -m_index.value(); } + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index rowOffset() const { return m_index.value()>0 ? 0 : -m_index.value(); } + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index colOffset() const { return m_index.value()>0 ? m_index.value() : 0; } + // trigger a compile-time error if someone try to call packet + template typename MatrixType::PacketReturnType packet(Index) const; + template typename MatrixType::PacketReturnType packet(Index,Index) const; +}; + +/** \returns an expression of the main diagonal of the matrix \c *this + * + * \c *this is not required to be square. + * + * Example: \include MatrixBase_diagonal.cpp + * Output: \verbinclude MatrixBase_diagonal.out + * + * \sa class Diagonal */ +template +inline typename MatrixBase::DiagonalReturnType +MatrixBase::diagonal() +{ + return DiagonalReturnType(derived()); +} + +/** This is the const version of diagonal(). */ +template +inline typename MatrixBase::ConstDiagonalReturnType +MatrixBase::diagonal() const +{ + return ConstDiagonalReturnType(derived()); +} + +/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this + * + * \c *this is not required to be square. + * + * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0 + * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal. + * + * Example: \include MatrixBase_diagonal_int.cpp + * Output: \verbinclude MatrixBase_diagonal_int.out + * + * \sa MatrixBase::diagonal(), class Diagonal */ +template +inline typename MatrixBase::DiagonalDynamicIndexReturnType +MatrixBase::diagonal(Index index) +{ + return DiagonalDynamicIndexReturnType(derived(), index); +} + +/** This is the const version of diagonal(Index). */ +template +inline typename MatrixBase::ConstDiagonalDynamicIndexReturnType +MatrixBase::diagonal(Index index) const +{ + return ConstDiagonalDynamicIndexReturnType(derived(), index); +} + +/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this + * + * \c *this is not required to be square. + * + * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0 + * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal. + * + * Example: \include MatrixBase_diagonal_template_int.cpp + * Output: \verbinclude MatrixBase_diagonal_template_int.out + * + * \sa MatrixBase::diagonal(), class Diagonal */ +template +template +inline typename MatrixBase::template DiagonalIndexReturnType::Type +MatrixBase::diagonal() +{ + return typename DiagonalIndexReturnType::Type(derived()); +} + +/** This is the const version of diagonal(). */ +template +template +inline typename MatrixBase::template ConstDiagonalIndexReturnType::Type +MatrixBase::diagonal() const +{ + return typename ConstDiagonalIndexReturnType::Type(derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_DIAGONAL_H diff --git a/3rdparty/eigen3/Eigen/src/Core/DiagonalMatrix.h b/3rdparty/eigen3/Eigen/src/Core/DiagonalMatrix.h new file mode 100644 index 0000000..ecfdce8 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/DiagonalMatrix.h @@ -0,0 +1,343 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// Copyright (C) 2007-2009 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_DIAGONALMATRIX_H +#define EIGEN_DIAGONALMATRIX_H + +namespace Eigen { + +#ifndef EIGEN_PARSED_BY_DOXYGEN +template +class DiagonalBase : public EigenBase +{ + public: + typedef typename internal::traits::DiagonalVectorType DiagonalVectorType; + typedef typename DiagonalVectorType::Scalar Scalar; + typedef typename DiagonalVectorType::RealScalar RealScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::StorageIndex StorageIndex; + + enum { + RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, + ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, + MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime, + MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime, + IsVectorAtCompileTime = 0, + Flags = NoPreferredStorageOrderBit + }; + + typedef Matrix DenseMatrixType; + typedef DenseMatrixType DenseType; + typedef DiagonalMatrix PlainObject; + + EIGEN_DEVICE_FUNC + inline const Derived& derived() const { return *static_cast(this); } + EIGEN_DEVICE_FUNC + inline Derived& derived() { return *static_cast(this); } + + EIGEN_DEVICE_FUNC + DenseMatrixType toDenseMatrix() const { return derived(); } + + EIGEN_DEVICE_FUNC + inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); } + EIGEN_DEVICE_FUNC + inline DiagonalVectorType& diagonal() { return derived().diagonal(); } + + EIGEN_DEVICE_FUNC + inline Index rows() const { return diagonal().size(); } + EIGEN_DEVICE_FUNC + inline Index cols() const { return diagonal().size(); } + + template + EIGEN_DEVICE_FUNC + const Product + operator*(const MatrixBase &matrix) const + { + return Product(derived(),matrix.derived()); + } + + typedef DiagonalWrapper, const DiagonalVectorType> > InverseReturnType; + EIGEN_DEVICE_FUNC + inline const InverseReturnType + inverse() const + { + return InverseReturnType(diagonal().cwiseInverse()); + } + + EIGEN_DEVICE_FUNC + inline const DiagonalWrapper + operator*(const Scalar& scalar) const + { + return DiagonalWrapper(diagonal() * scalar); + } + EIGEN_DEVICE_FUNC + friend inline const DiagonalWrapper + operator*(const Scalar& scalar, const DiagonalBase& other) + { + return DiagonalWrapper(scalar * other.diagonal()); + } +}; + +#endif + +/** \class DiagonalMatrix + * \ingroup Core_Module + * + * \brief Represents a diagonal matrix with its storage + * + * \param _Scalar the type of coefficients + * \param SizeAtCompileTime the dimension of the matrix, or Dynamic + * \param MaxSizeAtCompileTime the dimension of the matrix, or Dynamic. This parameter is optional and defaults + * to SizeAtCompileTime. Most of the time, you do not need to specify it. + * + * \sa class DiagonalWrapper + */ + +namespace internal { +template +struct traits > + : traits > +{ + typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType; + typedef DiagonalShape StorageKind; + enum { + Flags = LvalueBit | NoPreferredStorageOrderBit + }; +}; +} +template +class DiagonalMatrix + : public DiagonalBase > +{ + public: + #ifndef EIGEN_PARSED_BY_DOXYGEN + typedef typename internal::traits::DiagonalVectorType DiagonalVectorType; + typedef const DiagonalMatrix& Nested; + typedef _Scalar Scalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::StorageIndex StorageIndex; + #endif + + protected: + + DiagonalVectorType m_diagonal; + + public: + + /** const version of diagonal(). */ + EIGEN_DEVICE_FUNC + inline const DiagonalVectorType& diagonal() const { return m_diagonal; } + /** \returns a reference to the stored vector of diagonal coefficients. */ + EIGEN_DEVICE_FUNC + inline DiagonalVectorType& diagonal() { return m_diagonal; } + + /** Default constructor without initialization */ + EIGEN_DEVICE_FUNC + inline DiagonalMatrix() {} + + /** Constructs a diagonal matrix with given dimension */ + EIGEN_DEVICE_FUNC + explicit inline DiagonalMatrix(Index dim) : m_diagonal(dim) {} + + /** 2D constructor. */ + EIGEN_DEVICE_FUNC + inline DiagonalMatrix(const Scalar& x, const Scalar& y) : m_diagonal(x,y) {} + + /** 3D constructor. */ + EIGEN_DEVICE_FUNC + inline DiagonalMatrix(const Scalar& x, const Scalar& y, const Scalar& z) : m_diagonal(x,y,z) {} + + /** Copy constructor. */ + template + EIGEN_DEVICE_FUNC + inline DiagonalMatrix(const DiagonalBase& other) : m_diagonal(other.diagonal()) {} + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** copy constructor. prevent a default copy constructor from hiding the other templated constructor */ + inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {} + #endif + + /** generic constructor from expression of the diagonal coefficients */ + template + EIGEN_DEVICE_FUNC + explicit inline DiagonalMatrix(const MatrixBase& other) : m_diagonal(other) + {} + + /** Copy operator. */ + template + EIGEN_DEVICE_FUNC + DiagonalMatrix& operator=(const DiagonalBase& other) + { + m_diagonal = other.diagonal(); + return *this; + } + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** This is a special case of the templated operator=. Its purpose is to + * prevent a default operator= from hiding the templated operator=. + */ + EIGEN_DEVICE_FUNC + DiagonalMatrix& operator=(const DiagonalMatrix& other) + { + m_diagonal = other.diagonal(); + return *this; + } + #endif + + /** Resizes to given size. */ + EIGEN_DEVICE_FUNC + inline void resize(Index size) { m_diagonal.resize(size); } + /** Sets all coefficients to zero. */ + EIGEN_DEVICE_FUNC + inline void setZero() { m_diagonal.setZero(); } + /** Resizes and sets all coefficients to zero. */ + EIGEN_DEVICE_FUNC + inline void setZero(Index size) { m_diagonal.setZero(size); } + /** Sets this matrix to be the identity matrix of the current size. */ + EIGEN_DEVICE_FUNC + inline void setIdentity() { m_diagonal.setOnes(); } + /** Sets this matrix to be the identity matrix of the given size. */ + EIGEN_DEVICE_FUNC + inline void setIdentity(Index size) { m_diagonal.setOnes(size); } +}; + +/** \class DiagonalWrapper + * \ingroup Core_Module + * + * \brief Expression of a diagonal matrix + * + * \param _DiagonalVectorType the type of the vector of diagonal coefficients + * + * This class is an expression of a diagonal matrix, but not storing its own vector of diagonal coefficients, + * instead wrapping an existing vector expression. It is the return type of MatrixBase::asDiagonal() + * and most of the time this is the only way that it is used. + * + * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal() + */ + +namespace internal { +template +struct traits > +{ + typedef _DiagonalVectorType DiagonalVectorType; + typedef typename DiagonalVectorType::Scalar Scalar; + typedef typename DiagonalVectorType::StorageIndex StorageIndex; + typedef DiagonalShape StorageKind; + typedef typename traits::XprKind XprKind; + enum { + RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, + ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, + MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime, + MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime, + Flags = (traits::Flags & LvalueBit) | NoPreferredStorageOrderBit + }; +}; +} + +template +class DiagonalWrapper + : public DiagonalBase >, internal::no_assignment_operator +{ + public: + #ifndef EIGEN_PARSED_BY_DOXYGEN + typedef _DiagonalVectorType DiagonalVectorType; + typedef DiagonalWrapper Nested; + #endif + + /** Constructor from expression of diagonal coefficients to wrap. */ + EIGEN_DEVICE_FUNC + explicit inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {} + + /** \returns a const reference to the wrapped expression of diagonal coefficients. */ + EIGEN_DEVICE_FUNC + const DiagonalVectorType& diagonal() const { return m_diagonal; } + + protected: + typename DiagonalVectorType::Nested m_diagonal; +}; + +/** \returns a pseudo-expression of a diagonal matrix with *this as vector of diagonal coefficients + * + * \only_for_vectors + * + * Example: \include MatrixBase_asDiagonal.cpp + * Output: \verbinclude MatrixBase_asDiagonal.out + * + * \sa class DiagonalWrapper, class DiagonalMatrix, diagonal(), isDiagonal() + **/ +template +inline const DiagonalWrapper +MatrixBase::asDiagonal() const +{ + return DiagonalWrapper(derived()); +} + +/** \returns true if *this is approximately equal to a diagonal matrix, + * within the precision given by \a prec. + * + * Example: \include MatrixBase_isDiagonal.cpp + * Output: \verbinclude MatrixBase_isDiagonal.out + * + * \sa asDiagonal() + */ +template +bool MatrixBase::isDiagonal(const RealScalar& prec) const +{ + if(cols() != rows()) return false; + RealScalar maxAbsOnDiagonal = static_cast(-1); + for(Index j = 0; j < cols(); ++j) + { + RealScalar absOnDiagonal = numext::abs(coeff(j,j)); + if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal; + } + for(Index j = 0; j < cols(); ++j) + for(Index i = 0; i < j; ++i) + { + if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false; + if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false; + } + return true; +} + +namespace internal { + +template<> struct storage_kind_to_shape { typedef DiagonalShape Shape; }; + +struct Diagonal2Dense {}; + +template<> struct AssignmentKind { typedef Diagonal2Dense Kind; }; + +// Diagonal matrix to Dense assignment +template< typename DstXprType, typename SrcXprType, typename Functor> +struct Assignment +{ + static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op &/*func*/) + { + Index dstRows = src.rows(); + Index dstCols = src.cols(); + if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) + dst.resize(dstRows, dstCols); + + dst.setZero(); + dst.diagonal() = src.diagonal(); + } + + static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op &/*func*/) + { dst.diagonal() += src.diagonal(); } + + static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op &/*func*/) + { dst.diagonal() -= src.diagonal(); } +}; + +} // namespace internal + +} // end namespace Eigen + +#endif // EIGEN_DIAGONALMATRIX_H diff --git a/3rdparty/eigen3/Eigen/src/Core/DiagonalProduct.h b/3rdparty/eigen3/Eigen/src/Core/DiagonalProduct.h new file mode 100644 index 0000000..d372b93 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/DiagonalProduct.h @@ -0,0 +1,28 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2007-2009 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_DIAGONALPRODUCT_H +#define EIGEN_DIAGONALPRODUCT_H + +namespace Eigen { + +/** \returns the diagonal matrix product of \c *this by the diagonal matrix \a diagonal. + */ +template +template +inline const Product +MatrixBase::operator*(const DiagonalBase &a_diagonal) const +{ + return Product(derived(),a_diagonal.derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_DIAGONALPRODUCT_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Dot.h b/3rdparty/eigen3/Eigen/src/Core/Dot.h new file mode 100644 index 0000000..1fe7a84 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Dot.h @@ -0,0 +1,318 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2008, 2010 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_DOT_H +#define EIGEN_DOT_H + +namespace Eigen { + +namespace internal { + +// helper function for dot(). The problem is that if we put that in the body of dot(), then upon calling dot +// with mismatched types, the compiler emits errors about failing to instantiate cwiseProduct BEFORE +// looking at the static assertions. Thus this is a trick to get better compile errors. +template +struct dot_nocheck +{ + typedef scalar_conj_product_op::Scalar,typename traits::Scalar> conj_prod; + typedef typename conj_prod::result_type ResScalar; + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE + static ResScalar run(const MatrixBase& a, const MatrixBase& b) + { + return a.template binaryExpr(b).sum(); + } +}; + +template +struct dot_nocheck +{ + typedef scalar_conj_product_op::Scalar,typename traits::Scalar> conj_prod; + typedef typename conj_prod::result_type ResScalar; + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE + static ResScalar run(const MatrixBase& a, const MatrixBase& b) + { + return a.transpose().template binaryExpr(b).sum(); + } +}; + +} // end namespace internal + +/** \fn MatrixBase::dot + * \returns the dot product of *this with other. + * + * \only_for_vectors + * + * \note If the scalar type is complex numbers, then this function returns the hermitian + * (sesquilinear) dot product, conjugate-linear in the first variable and linear in the + * second variable. + * + * \sa squaredNorm(), norm() + */ +template +template +EIGEN_DEVICE_FUNC +EIGEN_STRONG_INLINE +typename ScalarBinaryOpTraits::Scalar,typename internal::traits::Scalar>::ReturnType +MatrixBase::dot(const MatrixBase& other) const +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) + EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) +#if !(defined(EIGEN_NO_STATIC_ASSERT) && defined(EIGEN_NO_DEBUG)) + typedef internal::scalar_conj_product_op func; + EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar); +#endif + + eigen_assert(size() == other.size()); + + return internal::dot_nocheck::run(*this, other); +} + +//---------- implementation of L2 norm and related functions ---------- + +/** \returns, for vectors, the squared \em l2 norm of \c *this, and for matrices the Frobenius norm. + * In both cases, it consists in the sum of the square of all the matrix entries. + * For vectors, this is also equals to the dot product of \c *this with itself. + * + * \sa dot(), norm(), lpNorm() + */ +template +EIGEN_STRONG_INLINE typename NumTraits::Scalar>::Real MatrixBase::squaredNorm() const +{ + return numext::real((*this).cwiseAbs2().sum()); +} + +/** \returns, for vectors, the \em l2 norm of \c *this, and for matrices the Frobenius norm. + * In both cases, it consists in the square root of the sum of the square of all the matrix entries. + * For vectors, this is also equals to the square root of the dot product of \c *this with itself. + * + * \sa lpNorm(), dot(), squaredNorm() + */ +template +EIGEN_STRONG_INLINE typename NumTraits::Scalar>::Real MatrixBase::norm() const +{ + return numext::sqrt(squaredNorm()); +} + +/** \returns an expression of the quotient of \c *this by its own norm. + * + * \warning If the input vector is too small (i.e., this->norm()==0), + * then this function returns a copy of the input. + * + * \only_for_vectors + * + * \sa norm(), normalize() + */ +template +EIGEN_STRONG_INLINE const typename MatrixBase::PlainObject +MatrixBase::normalized() const +{ + typedef typename internal::nested_eval::type _Nested; + _Nested n(derived()); + RealScalar z = n.squaredNorm(); + // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU + if(z>RealScalar(0)) + return n / numext::sqrt(z); + else + return n; +} + +/** Normalizes the vector, i.e. divides it by its own norm. + * + * \only_for_vectors + * + * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged. + * + * \sa norm(), normalized() + */ +template +EIGEN_STRONG_INLINE void MatrixBase::normalize() +{ + RealScalar z = squaredNorm(); + // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU + if(z>RealScalar(0)) + derived() /= numext::sqrt(z); +} + +/** \returns an expression of the quotient of \c *this by its own norm while avoiding underflow and overflow. + * + * \only_for_vectors + * + * This method is analogue to the normalized() method, but it reduces the risk of + * underflow and overflow when computing the norm. + * + * \warning If the input vector is too small (i.e., this->norm()==0), + * then this function returns a copy of the input. + * + * \sa stableNorm(), stableNormalize(), normalized() + */ +template +EIGEN_STRONG_INLINE const typename MatrixBase::PlainObject +MatrixBase::stableNormalized() const +{ + typedef typename internal::nested_eval::type _Nested; + _Nested n(derived()); + RealScalar w = n.cwiseAbs().maxCoeff(); + RealScalar z = (n/w).squaredNorm(); + if(z>RealScalar(0)) + return n / (numext::sqrt(z)*w); + else + return n; +} + +/** Normalizes the vector while avoid underflow and overflow + * + * \only_for_vectors + * + * This method is analogue to the normalize() method, but it reduces the risk of + * underflow and overflow when computing the norm. + * + * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged. + * + * \sa stableNorm(), stableNormalized(), normalize() + */ +template +EIGEN_STRONG_INLINE void MatrixBase::stableNormalize() +{ + RealScalar w = cwiseAbs().maxCoeff(); + RealScalar z = (derived()/w).squaredNorm(); + if(z>RealScalar(0)) + derived() /= numext::sqrt(z)*w; +} + +//---------- implementation of other norms ---------- + +namespace internal { + +template +struct lpNorm_selector +{ + typedef typename NumTraits::Scalar>::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const MatrixBase& m) + { + EIGEN_USING_STD_MATH(pow) + return pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1)/p); + } +}; + +template +struct lpNorm_selector +{ + EIGEN_DEVICE_FUNC + static inline typename NumTraits::Scalar>::Real run(const MatrixBase& m) + { + return m.cwiseAbs().sum(); + } +}; + +template +struct lpNorm_selector +{ + EIGEN_DEVICE_FUNC + static inline typename NumTraits::Scalar>::Real run(const MatrixBase& m) + { + return m.norm(); + } +}; + +template +struct lpNorm_selector +{ + typedef typename NumTraits::Scalar>::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const MatrixBase& m) + { + if(Derived::SizeAtCompileTime==0 || (Derived::SizeAtCompileTime==Dynamic && m.size()==0)) + return RealScalar(0); + return m.cwiseAbs().maxCoeff(); + } +}; + +} // end namespace internal + +/** \returns the \b coefficient-wise \f$ \ell^p \f$ norm of \c *this, that is, returns the p-th root of the sum of the p-th powers of the absolute values + * of the coefficients of \c *this. If \a p is the special value \a Eigen::Infinity, this function returns the \f$ \ell^\infty \f$ + * norm, that is the maximum of the absolute values of the coefficients of \c *this. + * + * In all cases, if \c *this is empty, then the value 0 is returned. + * + * \note For matrices, this function does not compute the operator-norm. That is, if \c *this is a matrix, then its coefficients are interpreted as a 1D vector. Nonetheless, you can easily compute the 1-norm and \f$\infty\f$-norm matrix operator norms using \link TutorialReductionsVisitorsBroadcastingReductionsNorm partial reductions \endlink. + * + * \sa norm() + */ +template +template +#ifndef EIGEN_PARSED_BY_DOXYGEN +inline typename NumTraits::Scalar>::Real +#else +MatrixBase::RealScalar +#endif +MatrixBase::lpNorm() const +{ + return internal::lpNorm_selector::run(*this); +} + +//---------- implementation of isOrthogonal / isUnitary ---------- + +/** \returns true if *this is approximately orthogonal to \a other, + * within the precision given by \a prec. + * + * Example: \include MatrixBase_isOrthogonal.cpp + * Output: \verbinclude MatrixBase_isOrthogonal.out + */ +template +template +bool MatrixBase::isOrthogonal +(const MatrixBase& other, const RealScalar& prec) const +{ + typename internal::nested_eval::type nested(derived()); + typename internal::nested_eval::type otherNested(other.derived()); + return numext::abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm(); +} + +/** \returns true if *this is approximately an unitary matrix, + * within the precision given by \a prec. In the case where the \a Scalar + * type is real numbers, a unitary matrix is an orthogonal matrix, whence the name. + * + * \note This can be used to check whether a family of vectors forms an orthonormal basis. + * Indeed, \c m.isUnitary() returns true if and only if the columns (equivalently, the rows) of m form an + * orthonormal basis. + * + * Example: \include MatrixBase_isUnitary.cpp + * Output: \verbinclude MatrixBase_isUnitary.out + */ +template +bool MatrixBase::isUnitary(const RealScalar& prec) const +{ + typename internal::nested_eval::type self(derived()); + for(Index i = 0; i < cols(); ++i) + { + if(!internal::isApprox(self.col(i).squaredNorm(), static_cast(1), prec)) + return false; + for(Index j = 0; j < i; ++j) + if(!internal::isMuchSmallerThan(self.col(i).dot(self.col(j)), static_cast(1), prec)) + return false; + } + return true; +} + +} // end namespace Eigen + +#endif // EIGEN_DOT_H diff --git a/3rdparty/eigen3/Eigen/src/Core/EigenBase.h b/3rdparty/eigen3/Eigen/src/Core/EigenBase.h new file mode 100644 index 0000000..b195506 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/EigenBase.h @@ -0,0 +1,159 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Benoit Jacob +// Copyright (C) 2009 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_EIGENBASE_H +#define EIGEN_EIGENBASE_H + +namespace Eigen { + +/** \class EigenBase + * \ingroup Core_Module + * + * Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor MatrixBase(T). + * + * In other words, an EigenBase object is an object that can be copied into a MatrixBase. + * + * Besides MatrixBase-derived classes, this also includes special matrix classes such as diagonal matrices, etc. + * + * Notice that this class is trivial, it is only used to disambiguate overloaded functions. + * + * \sa \blank \ref TopicClassHierarchy + */ +template struct EigenBase +{ +// typedef typename internal::plain_matrix_type::type PlainObject; + + /** \brief The interface type of indices + * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE. + * \deprecated Since Eigen 3.3, its usage is deprecated. Use Eigen::Index instead. + * \sa StorageIndex, \ref TopicPreprocessorDirectives. + */ + typedef Eigen::Index Index; + + // FIXME is it needed? + typedef typename internal::traits::StorageKind StorageKind; + + /** \returns a reference to the derived object */ + EIGEN_DEVICE_FUNC + Derived& derived() { return *static_cast(this); } + /** \returns a const reference to the derived object */ + EIGEN_DEVICE_FUNC + const Derived& derived() const { return *static_cast(this); } + + EIGEN_DEVICE_FUNC + inline Derived& const_cast_derived() const + { return *static_cast(const_cast(this)); } + EIGEN_DEVICE_FUNC + inline const Derived& const_derived() const + { return *static_cast(this); } + + /** \returns the number of rows. \sa cols(), RowsAtCompileTime */ + EIGEN_DEVICE_FUNC + inline Index rows() const { return derived().rows(); } + /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/ + EIGEN_DEVICE_FUNC + inline Index cols() const { return derived().cols(); } + /** \returns the number of coefficients, which is rows()*cols(). + * \sa rows(), cols(), SizeAtCompileTime. */ + EIGEN_DEVICE_FUNC + inline Index size() const { return rows() * cols(); } + + /** \internal Don't use it, but do the equivalent: \code dst = *this; \endcode */ + template + EIGEN_DEVICE_FUNC + inline void evalTo(Dest& dst) const + { derived().evalTo(dst); } + + /** \internal Don't use it, but do the equivalent: \code dst += *this; \endcode */ + template + EIGEN_DEVICE_FUNC + inline void addTo(Dest& dst) const + { + // This is the default implementation, + // derived class can reimplement it in a more optimized way. + typename Dest::PlainObject res(rows(),cols()); + evalTo(res); + dst += res; + } + + /** \internal Don't use it, but do the equivalent: \code dst -= *this; \endcode */ + template + EIGEN_DEVICE_FUNC + inline void subTo(Dest& dst) const + { + // This is the default implementation, + // derived class can reimplement it in a more optimized way. + typename Dest::PlainObject res(rows(),cols()); + evalTo(res); + dst -= res; + } + + /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheRight(*this); \endcode */ + template + EIGEN_DEVICE_FUNC inline void applyThisOnTheRight(Dest& dst) const + { + // This is the default implementation, + // derived class can reimplement it in a more optimized way. + dst = dst * this->derived(); + } + + /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheLeft(*this); \endcode */ + template + EIGEN_DEVICE_FUNC inline void applyThisOnTheLeft(Dest& dst) const + { + // This is the default implementation, + // derived class can reimplement it in a more optimized way. + dst = this->derived() * dst; + } + +}; + +/*************************************************************************** +* Implementation of matrix base methods +***************************************************************************/ + +/** \brief Copies the generic expression \a other into *this. + * + * \details The expression must provide a (templated) evalTo(Derived& dst) const + * function which does the actual job. In practice, this allows any user to write + * its own special matrix without having to modify MatrixBase + * + * \returns a reference to *this. + */ +template +template +EIGEN_DEVICE_FUNC +Derived& DenseBase::operator=(const EigenBase &other) +{ + call_assignment(derived(), other.derived()); + return derived(); +} + +template +template +EIGEN_DEVICE_FUNC +Derived& DenseBase::operator+=(const EigenBase &other) +{ + call_assignment(derived(), other.derived(), internal::add_assign_op()); + return derived(); +} + +template +template +EIGEN_DEVICE_FUNC +Derived& DenseBase::operator-=(const EigenBase &other) +{ + call_assignment(derived(), other.derived(), internal::sub_assign_op()); + return derived(); +} + +} // end namespace Eigen + +#endif // EIGEN_EIGENBASE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/ForceAlignedAccess.h b/3rdparty/eigen3/Eigen/src/Core/ForceAlignedAccess.h new file mode 100644 index 0000000..7b08b45 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/ForceAlignedAccess.h @@ -0,0 +1,146 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_FORCEALIGNEDACCESS_H +#define EIGEN_FORCEALIGNEDACCESS_H + +namespace Eigen { + +/** \class ForceAlignedAccess + * \ingroup Core_Module + * + * \brief Enforce aligned packet loads and stores regardless of what is requested + * + * \param ExpressionType the type of the object of which we are forcing aligned packet access + * + * This class is the return type of MatrixBase::forceAlignedAccess() + * and most of the time this is the only way it is used. + * + * \sa MatrixBase::forceAlignedAccess() + */ + +namespace internal { +template +struct traits > : public traits +{}; +} + +template class ForceAlignedAccess + : public internal::dense_xpr_base< ForceAlignedAccess >::type +{ + public: + + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess) + + EIGEN_DEVICE_FUNC explicit inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {} + + EIGEN_DEVICE_FUNC inline Index rows() const { return m_expression.rows(); } + EIGEN_DEVICE_FUNC inline Index cols() const { return m_expression.cols(); } + EIGEN_DEVICE_FUNC inline Index outerStride() const { return m_expression.outerStride(); } + EIGEN_DEVICE_FUNC inline Index innerStride() const { return m_expression.innerStride(); } + + EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const + { + return m_expression.coeff(row, col); + } + + EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) + { + return m_expression.const_cast_derived().coeffRef(row, col); + } + + EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const + { + return m_expression.coeff(index); + } + + EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index) + { + return m_expression.const_cast_derived().coeffRef(index); + } + + template + inline const PacketScalar packet(Index row, Index col) const + { + return m_expression.template packet(row, col); + } + + template + inline void writePacket(Index row, Index col, const PacketScalar& x) + { + m_expression.const_cast_derived().template writePacket(row, col, x); + } + + template + inline const PacketScalar packet(Index index) const + { + return m_expression.template packet(index); + } + + template + inline void writePacket(Index index, const PacketScalar& x) + { + m_expression.const_cast_derived().template writePacket(index, x); + } + + EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; } + + protected: + const ExpressionType& m_expression; + + private: + ForceAlignedAccess& operator=(const ForceAlignedAccess&); +}; + +/** \returns an expression of *this with forced aligned access + * \sa forceAlignedAccessIf(),class ForceAlignedAccess + */ +template +inline const ForceAlignedAccess +MatrixBase::forceAlignedAccess() const +{ + return ForceAlignedAccess(derived()); +} + +/** \returns an expression of *this with forced aligned access + * \sa forceAlignedAccessIf(), class ForceAlignedAccess + */ +template +inline ForceAlignedAccess +MatrixBase::forceAlignedAccess() +{ + return ForceAlignedAccess(derived()); +} + +/** \returns an expression of *this with forced aligned access if \a Enable is true. + * \sa forceAlignedAccess(), class ForceAlignedAccess + */ +template +template +inline typename internal::add_const_on_value_type,Derived&>::type>::type +MatrixBase::forceAlignedAccessIf() const +{ + return derived(); // FIXME This should not work but apparently is never used +} + +/** \returns an expression of *this with forced aligned access if \a Enable is true. + * \sa forceAlignedAccess(), class ForceAlignedAccess + */ +template +template +inline typename internal::conditional,Derived&>::type +MatrixBase::forceAlignedAccessIf() +{ + return derived(); // FIXME This should not work but apparently is never used +} + +} // end namespace Eigen + +#endif // EIGEN_FORCEALIGNEDACCESS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Fuzzy.h b/3rdparty/eigen3/Eigen/src/Core/Fuzzy.h new file mode 100644 index 0000000..3e403a0 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Fuzzy.h @@ -0,0 +1,155 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2008 Benoit Jacob +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_FUZZY_H +#define EIGEN_FUZZY_H + +namespace Eigen { + +namespace internal +{ + +template::IsInteger> +struct isApprox_selector +{ + EIGEN_DEVICE_FUNC + static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec) + { + typename internal::nested_eval::type nested(x); + typename internal::nested_eval::type otherNested(y); + return (nested - otherNested).cwiseAbs2().sum() <= prec * prec * numext::mini(nested.cwiseAbs2().sum(), otherNested.cwiseAbs2().sum()); + } +}; + +template +struct isApprox_selector +{ + EIGEN_DEVICE_FUNC + static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar&) + { + return x.matrix() == y.matrix(); + } +}; + +template::IsInteger> +struct isMuchSmallerThan_object_selector +{ + EIGEN_DEVICE_FUNC + static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec) + { + return x.cwiseAbs2().sum() <= numext::abs2(prec) * y.cwiseAbs2().sum(); + } +}; + +template +struct isMuchSmallerThan_object_selector +{ + EIGEN_DEVICE_FUNC + static bool run(const Derived& x, const OtherDerived&, const typename Derived::RealScalar&) + { + return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix(); + } +}; + +template::IsInteger> +struct isMuchSmallerThan_scalar_selector +{ + EIGEN_DEVICE_FUNC + static bool run(const Derived& x, const typename Derived::RealScalar& y, const typename Derived::RealScalar& prec) + { + return x.cwiseAbs2().sum() <= numext::abs2(prec * y); + } +}; + +template +struct isMuchSmallerThan_scalar_selector +{ + EIGEN_DEVICE_FUNC + static bool run(const Derived& x, const typename Derived::RealScalar&, const typename Derived::RealScalar&) + { + return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix(); + } +}; + +} // end namespace internal + + +/** \returns \c true if \c *this is approximately equal to \a other, within the precision + * determined by \a prec. + * + * \note The fuzzy compares are done multiplicatively. Two vectors \f$ v \f$ and \f$ w \f$ + * are considered to be approximately equal within precision \f$ p \f$ if + * \f[ \Vert v - w \Vert \leqslant p\,\min(\Vert v\Vert, \Vert w\Vert). \f] + * For matrices, the comparison is done using the Hilbert-Schmidt norm (aka Frobenius norm + * L2 norm). + * + * \note Because of the multiplicativeness of this comparison, one can't use this function + * to check whether \c *this is approximately equal to the zero matrix or vector. + * Indeed, \c isApprox(zero) returns false unless \c *this itself is exactly the zero matrix + * or vector. If you want to test whether \c *this is zero, use internal::isMuchSmallerThan(const + * RealScalar&, RealScalar) instead. + * + * \sa internal::isMuchSmallerThan(const RealScalar&, RealScalar) const + */ +template +template +bool DenseBase::isApprox( + const DenseBase& other, + const RealScalar& prec +) const +{ + return internal::isApprox_selector::run(derived(), other.derived(), prec); +} + +/** \returns \c true if the norm of \c *this is much smaller than \a other, + * within the precision determined by \a prec. + * + * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is + * considered to be much smaller than \f$ x \f$ within precision \f$ p \f$ if + * \f[ \Vert v \Vert \leqslant p\,\vert x\vert. \f] + * + * For matrices, the comparison is done using the Hilbert-Schmidt norm. For this reason, + * the value of the reference scalar \a other should come from the Hilbert-Schmidt norm + * of a reference matrix of same dimensions. + * + * \sa isApprox(), isMuchSmallerThan(const DenseBase&, RealScalar) const + */ +template +bool DenseBase::isMuchSmallerThan( + const typename NumTraits::Real& other, + const RealScalar& prec +) const +{ + return internal::isMuchSmallerThan_scalar_selector::run(derived(), other, prec); +} + +/** \returns \c true if the norm of \c *this is much smaller than the norm of \a other, + * within the precision determined by \a prec. + * + * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is + * considered to be much smaller than a vector \f$ w \f$ within precision \f$ p \f$ if + * \f[ \Vert v \Vert \leqslant p\,\Vert w\Vert. \f] + * For matrices, the comparison is done using the Hilbert-Schmidt norm. + * + * \sa isApprox(), isMuchSmallerThan(const RealScalar&, RealScalar) const + */ +template +template +bool DenseBase::isMuchSmallerThan( + const DenseBase& other, + const RealScalar& prec +) const +{ + return internal::isMuchSmallerThan_object_selector::run(derived(), other.derived(), prec); +} + +} // end namespace Eigen + +#endif // EIGEN_FUZZY_H diff --git a/3rdparty/eigen3/Eigen/src/Core/GeneralProduct.h b/3rdparty/eigen3/Eigen/src/Core/GeneralProduct.h new file mode 100644 index 0000000..6f0cc80 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/GeneralProduct.h @@ -0,0 +1,455 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2008 Benoit Jacob +// Copyright (C) 2008-2011 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_GENERAL_PRODUCT_H +#define EIGEN_GENERAL_PRODUCT_H + +namespace Eigen { + +enum { + Large = 2, + Small = 3 +}; + +namespace internal { + +template struct product_type_selector; + +template struct product_size_category +{ + enum { + #ifndef EIGEN_CUDA_ARCH + is_large = MaxSize == Dynamic || + Size >= EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD || + (Size==Dynamic && MaxSize>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD), + #else + is_large = 0, + #endif + value = is_large ? Large + : Size == 1 ? 1 + : Small + }; +}; + +template struct product_type +{ + typedef typename remove_all::type _Lhs; + typedef typename remove_all::type _Rhs; + enum { + MaxRows = traits<_Lhs>::MaxRowsAtCompileTime, + Rows = traits<_Lhs>::RowsAtCompileTime, + MaxCols = traits<_Rhs>::MaxColsAtCompileTime, + Cols = traits<_Rhs>::ColsAtCompileTime, + MaxDepth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::MaxColsAtCompileTime, + traits<_Rhs>::MaxRowsAtCompileTime), + Depth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::ColsAtCompileTime, + traits<_Rhs>::RowsAtCompileTime) + }; + + // the splitting into different lines of code here, introducing the _select enums and the typedef below, + // is to work around an internal compiler error with gcc 4.1 and 4.2. +private: + enum { + rows_select = product_size_category::value, + cols_select = product_size_category::value, + depth_select = product_size_category::value + }; + typedef product_type_selector selector; + +public: + enum { + value = selector::ret, + ret = selector::ret + }; +#ifdef EIGEN_DEBUG_PRODUCT + static void debug() + { + EIGEN_DEBUG_VAR(Rows); + EIGEN_DEBUG_VAR(Cols); + EIGEN_DEBUG_VAR(Depth); + EIGEN_DEBUG_VAR(rows_select); + EIGEN_DEBUG_VAR(cols_select); + EIGEN_DEBUG_VAR(depth_select); + EIGEN_DEBUG_VAR(value); + } +#endif +}; + +/* The following allows to select the kind of product at compile time + * based on the three dimensions of the product. + * This is a compile time mapping from {1,Small,Large}^3 -> {product types} */ +// FIXME I'm not sure the current mapping is the ideal one. +template struct product_type_selector { enum { ret = OuterProduct }; }; +template struct product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; +template struct product_type_selector<1, N, 1> { enum { ret = LazyCoeffBasedProductMode }; }; +template struct product_type_selector<1, 1, Depth> { enum { ret = InnerProduct }; }; +template<> struct product_type_selector<1, 1, 1> { enum { ret = InnerProduct }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<1, Small,Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector<1, Large,Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<1, Large,Large> { enum { ret = GemvProduct }; }; +template<> struct product_type_selector<1, Small,Large> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = GemvProduct }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; + +} // end namespace internal + +/*********************************************************************** +* Implementation of Inner Vector Vector Product +***********************************************************************/ + +// FIXME : maybe the "inner product" could return a Scalar +// instead of a 1x1 matrix ?? +// Pro: more natural for the user +// Cons: this could be a problem if in a meta unrolled algorithm a matrix-matrix +// product ends up to a row-vector times col-vector product... To tackle this use +// case, we could have a specialization for Block with: operator=(Scalar x); + +/*********************************************************************** +* Implementation of Outer Vector Vector Product +***********************************************************************/ + +/*********************************************************************** +* Implementation of General Matrix Vector Product +***********************************************************************/ + +/* According to the shape/flags of the matrix we have to distinghish 3 different cases: + * 1 - the matrix is col-major, BLAS compatible and M is large => call fast BLAS-like colmajor routine + * 2 - the matrix is row-major, BLAS compatible and N is large => call fast BLAS-like rowmajor routine + * 3 - all other cases are handled using a simple loop along the outer-storage direction. + * Therefore we need a lower level meta selector. + * Furthermore, if the matrix is the rhs, then the product has to be transposed. + */ +namespace internal { + +template +struct gemv_dense_selector; + +} // end namespace internal + +namespace internal { + +template struct gemv_static_vector_if; + +template +struct gemv_static_vector_if +{ + EIGEN_STRONG_INLINE Scalar* data() { eigen_internal_assert(false && "should never be called"); return 0; } +}; + +template +struct gemv_static_vector_if +{ + EIGEN_STRONG_INLINE Scalar* data() { return 0; } +}; + +template +struct gemv_static_vector_if +{ + enum { + ForceAlignment = internal::packet_traits::Vectorizable, + PacketSize = internal::packet_traits::size + }; + #if EIGEN_MAX_STATIC_ALIGN_BYTES!=0 + internal::plain_array m_data; + EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; } + #else + // Some architectures cannot align on the stack, + // => let's manually enforce alignment by allocating more data and return the address of the first aligned element. + internal::plain_array m_data; + EIGEN_STRONG_INLINE Scalar* data() { + return ForceAlignment + ? reinterpret_cast((internal::UIntPtr(m_data.array) & ~(std::size_t(EIGEN_MAX_ALIGN_BYTES-1))) + EIGEN_MAX_ALIGN_BYTES) + : m_data.array; + } + #endif +}; + +// The vector is on the left => transposition +template +struct gemv_dense_selector +{ + template + static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha) + { + Transpose destT(dest); + enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor }; + gemv_dense_selector + ::run(rhs.transpose(), lhs.transpose(), destT, alpha); + } +}; + +template<> struct gemv_dense_selector +{ + template + static inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha) + { + typedef typename Lhs::Scalar LhsScalar; + typedef typename Rhs::Scalar RhsScalar; + typedef typename Dest::Scalar ResScalar; + typedef typename Dest::RealScalar RealScalar; + + typedef internal::blas_traits LhsBlasTraits; + typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType; + typedef internal::blas_traits RhsBlasTraits; + typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType; + + typedef Map, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits::size)> MappedDest; + + ActualLhsType actualLhs = LhsBlasTraits::extract(lhs); + ActualRhsType actualRhs = RhsBlasTraits::extract(rhs); + + ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs) + * RhsBlasTraits::extractScalarFactor(rhs); + + // make sure Dest is a compile-time vector type (bug 1166) + typedef typename conditional::type ActualDest; + + enum { + // FIXME find a way to allow an inner stride on the result if packet_traits::size==1 + // on, the other hand it is good for the cache to pack the vector anyways... + EvalToDestAtCompileTime = (ActualDest::InnerStrideAtCompileTime==1), + ComplexByReal = (NumTraits::IsComplex) && (!NumTraits::IsComplex), + MightCannotUseDest = (!EvalToDestAtCompileTime) || ComplexByReal + }; + + typedef const_blas_data_mapper LhsMapper; + typedef const_blas_data_mapper RhsMapper; + RhsScalar compatibleAlpha = get_factor::run(actualAlpha); + + if(!MightCannotUseDest) + { + // shortcut if we are sure to be able to use dest directly, + // this ease the compiler to generate cleaner and more optimzized code for most common cases + general_matrix_vector_product + ::run( + actualLhs.rows(), actualLhs.cols(), + LhsMapper(actualLhs.data(), actualLhs.outerStride()), + RhsMapper(actualRhs.data(), actualRhs.innerStride()), + dest.data(), 1, + compatibleAlpha); + } + else + { + gemv_static_vector_if static_dest; + + const bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0)); + const bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible; + + ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(), + evalToDest ? dest.data() : static_dest.data()); + + if(!evalToDest) + { + #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + Index size = dest.size(); + EIGEN_DENSE_STORAGE_CTOR_PLUGIN + #endif + if(!alphaIsCompatible) + { + MappedDest(actualDestPtr, dest.size()).setZero(); + compatibleAlpha = RhsScalar(1); + } + else + MappedDest(actualDestPtr, dest.size()) = dest; + } + + general_matrix_vector_product + ::run( + actualLhs.rows(), actualLhs.cols(), + LhsMapper(actualLhs.data(), actualLhs.outerStride()), + RhsMapper(actualRhs.data(), actualRhs.innerStride()), + actualDestPtr, 1, + compatibleAlpha); + + if (!evalToDest) + { + if(!alphaIsCompatible) + dest.matrix() += actualAlpha * MappedDest(actualDestPtr, dest.size()); + else + dest = MappedDest(actualDestPtr, dest.size()); + } + } + } +}; + +template<> struct gemv_dense_selector +{ + template + static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha) + { + typedef typename Lhs::Scalar LhsScalar; + typedef typename Rhs::Scalar RhsScalar; + typedef typename Dest::Scalar ResScalar; + + typedef internal::blas_traits LhsBlasTraits; + typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType; + typedef internal::blas_traits RhsBlasTraits; + typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType; + typedef typename internal::remove_all::type ActualRhsTypeCleaned; + + typename add_const::type actualLhs = LhsBlasTraits::extract(lhs); + typename add_const::type actualRhs = RhsBlasTraits::extract(rhs); + + ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs) + * RhsBlasTraits::extractScalarFactor(rhs); + + enum { + // FIXME find a way to allow an inner stride on the result if packet_traits::size==1 + // on, the other hand it is good for the cache to pack the vector anyways... + DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1 + }; + + gemv_static_vector_if static_rhs; + + ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(), + DirectlyUseRhs ? const_cast(actualRhs.data()) : static_rhs.data()); + + if(!DirectlyUseRhs) + { + #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + Index size = actualRhs.size(); + EIGEN_DENSE_STORAGE_CTOR_PLUGIN + #endif + Map(actualRhsPtr, actualRhs.size()) = actualRhs; + } + + typedef const_blas_data_mapper LhsMapper; + typedef const_blas_data_mapper RhsMapper; + general_matrix_vector_product + ::run( + actualLhs.rows(), actualLhs.cols(), + LhsMapper(actualLhs.data(), actualLhs.outerStride()), + RhsMapper(actualRhsPtr, 1), + dest.data(), dest.col(0).innerStride(), //NOTE if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166) + actualAlpha); + } +}; + +template<> struct gemv_dense_selector +{ + template + static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha) + { + EIGEN_STATIC_ASSERT((!nested_eval::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE); + // TODO if rhs is large enough it might be beneficial to make sure that dest is sequentially stored in memory, otherwise use a temp + typename nested_eval::type actual_rhs(rhs); + const Index size = rhs.rows(); + for(Index k=0; k struct gemv_dense_selector +{ + template + static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha) + { + EIGEN_STATIC_ASSERT((!nested_eval::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE); + typename nested_eval::type actual_rhs(rhs); + const Index rows = dest.rows(); + for(Index i=0; i +template +inline const Product +MatrixBase::operator*(const MatrixBase &other) const +{ + // A note regarding the function declaration: In MSVC, this function will sometimes + // not be inlined since DenseStorage is an unwindable object for dynamic + // matrices and product types are holding a member to store the result. + // Thus it does not help tagging this function with EIGEN_STRONG_INLINE. + enum { + ProductIsValid = Derived::ColsAtCompileTime==Dynamic + || OtherDerived::RowsAtCompileTime==Dynamic + || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime), + AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime, + SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived) + }; + // note to the lost user: + // * for a dot product use: v1.dot(v2) + // * for a coeff-wise product use: v1.cwiseProduct(v2) + EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes), + INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS) + EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors), + INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION) + EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT) +#ifdef EIGEN_DEBUG_PRODUCT + internal::product_type::debug(); +#endif + + return Product(derived(), other.derived()); +} + +/** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation. + * + * The returned product will behave like any other expressions: the coefficients of the product will be + * computed once at a time as requested. This might be useful in some extremely rare cases when only + * a small and no coherent fraction of the result's coefficients have to be computed. + * + * \warning This version of the matrix product can be much much slower. So use it only if you know + * what you are doing and that you measured a true speed improvement. + * + * \sa operator*(const MatrixBase&) + */ +template +template +const Product +MatrixBase::lazyProduct(const MatrixBase &other) const +{ + enum { + ProductIsValid = Derived::ColsAtCompileTime==Dynamic + || OtherDerived::RowsAtCompileTime==Dynamic + || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime), + AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime, + SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived) + }; + // note to the lost user: + // * for a dot product use: v1.dot(v2) + // * for a coeff-wise product use: v1.cwiseProduct(v2) + EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes), + INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS) + EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors), + INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION) + EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT) + + return Product(derived(), other.derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_PRODUCT_H diff --git a/3rdparty/eigen3/Eigen/src/Core/GenericPacketMath.h b/3rdparty/eigen3/Eigen/src/Core/GenericPacketMath.h new file mode 100644 index 0000000..029f8ac --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/GenericPacketMath.h @@ -0,0 +1,593 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_GENERIC_PACKET_MATH_H +#define EIGEN_GENERIC_PACKET_MATH_H + +namespace Eigen { + +namespace internal { + +/** \internal + * \file GenericPacketMath.h + * + * Default implementation for types not supported by the vectorization. + * In practice these functions are provided to make easier the writing + * of generic vectorized code. + */ + +#ifndef EIGEN_DEBUG_ALIGNED_LOAD +#define EIGEN_DEBUG_ALIGNED_LOAD +#endif + +#ifndef EIGEN_DEBUG_UNALIGNED_LOAD +#define EIGEN_DEBUG_UNALIGNED_LOAD +#endif + +#ifndef EIGEN_DEBUG_ALIGNED_STORE +#define EIGEN_DEBUG_ALIGNED_STORE +#endif + +#ifndef EIGEN_DEBUG_UNALIGNED_STORE +#define EIGEN_DEBUG_UNALIGNED_STORE +#endif + +struct default_packet_traits +{ + enum { + HasHalfPacket = 0, + + HasAdd = 1, + HasSub = 1, + HasMul = 1, + HasNegate = 1, + HasAbs = 1, + HasArg = 0, + HasAbs2 = 1, + HasMin = 1, + HasMax = 1, + HasConj = 1, + HasSetLinear = 1, + HasBlend = 0, + + HasDiv = 0, + HasSqrt = 0, + HasRsqrt = 0, + HasExp = 0, + HasLog = 0, + HasLog1p = 0, + HasLog10 = 0, + HasPow = 0, + + HasSin = 0, + HasCos = 0, + HasTan = 0, + HasASin = 0, + HasACos = 0, + HasATan = 0, + HasSinh = 0, + HasCosh = 0, + HasTanh = 0, + HasLGamma = 0, + HasDiGamma = 0, + HasZeta = 0, + HasPolygamma = 0, + HasErf = 0, + HasErfc = 0, + HasIGamma = 0, + HasIGammac = 0, + HasBetaInc = 0, + + HasRound = 0, + HasFloor = 0, + HasCeil = 0, + + HasSign = 0 + }; +}; + +template struct packet_traits : default_packet_traits +{ + typedef T type; + typedef T half; + enum { + Vectorizable = 0, + size = 1, + AlignedOnScalar = 0, + HasHalfPacket = 0 + }; + enum { + HasAdd = 0, + HasSub = 0, + HasMul = 0, + HasNegate = 0, + HasAbs = 0, + HasAbs2 = 0, + HasMin = 0, + HasMax = 0, + HasConj = 0, + HasSetLinear = 0 + }; +}; + +template struct packet_traits : packet_traits { }; + +template struct type_casting_traits { + enum { + VectorizedCast = 0, + SrcCoeffRatio = 1, + TgtCoeffRatio = 1 + }; +}; + + +/** \internal \returns static_cast(a) (coeff-wise) */ +template +EIGEN_DEVICE_FUNC inline TgtPacket +pcast(const SrcPacket& a) { + return static_cast(a); +} +template +EIGEN_DEVICE_FUNC inline TgtPacket +pcast(const SrcPacket& a, const SrcPacket& /*b*/) { + return static_cast(a); +} + +template +EIGEN_DEVICE_FUNC inline TgtPacket +pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/) { + return static_cast(a); +} + +/** \internal \returns a + b (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +padd(const Packet& a, + const Packet& b) { return a+b; } + +/** \internal \returns a - b (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +psub(const Packet& a, + const Packet& b) { return a-b; } + +/** \internal \returns -a (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +pnegate(const Packet& a) { return -a; } + +/** \internal \returns conj(a) (coeff-wise) */ + +template EIGEN_DEVICE_FUNC inline Packet +pconj(const Packet& a) { return numext::conj(a); } + +/** \internal \returns a * b (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +pmul(const Packet& a, + const Packet& b) { return a*b; } + +/** \internal \returns a / b (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +pdiv(const Packet& a, + const Packet& b) { return a/b; } + +/** \internal \returns the min of \a a and \a b (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +pmin(const Packet& a, + const Packet& b) { return numext::mini(a, b); } + +/** \internal \returns the max of \a a and \a b (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +pmax(const Packet& a, + const Packet& b) { return numext::maxi(a, b); } + +/** \internal \returns the absolute value of \a a */ +template EIGEN_DEVICE_FUNC inline Packet +pabs(const Packet& a) { using std::abs; return abs(a); } + +/** \internal \returns the phase angle of \a a */ +template EIGEN_DEVICE_FUNC inline Packet +parg(const Packet& a) { using numext::arg; return arg(a); } + +/** \internal \returns the bitwise and of \a a and \a b */ +template EIGEN_DEVICE_FUNC inline Packet +pand(const Packet& a, const Packet& b) { return a & b; } + +/** \internal \returns the bitwise or of \a a and \a b */ +template EIGEN_DEVICE_FUNC inline Packet +por(const Packet& a, const Packet& b) { return a | b; } + +/** \internal \returns the bitwise xor of \a a and \a b */ +template EIGEN_DEVICE_FUNC inline Packet +pxor(const Packet& a, const Packet& b) { return a ^ b; } + +/** \internal \returns the bitwise andnot of \a a and \a b */ +template EIGEN_DEVICE_FUNC inline Packet +pandnot(const Packet& a, const Packet& b) { return a & (!b); } + +/** \internal \returns a packet version of \a *from, from must be 16 bytes aligned */ +template EIGEN_DEVICE_FUNC inline Packet +pload(const typename unpacket_traits::type* from) { return *from; } + +/** \internal \returns a packet version of \a *from, (un-aligned load) */ +template EIGEN_DEVICE_FUNC inline Packet +ploadu(const typename unpacket_traits::type* from) { return *from; } + +/** \internal \returns a packet with constant coefficients \a a, e.g.: (a,a,a,a) */ +template EIGEN_DEVICE_FUNC inline Packet +pset1(const typename unpacket_traits::type& a) { return a; } + +/** \internal \returns a packet with constant coefficients \a a[0], e.g.: (a[0],a[0],a[0],a[0]) */ +template EIGEN_DEVICE_FUNC inline Packet +pload1(const typename unpacket_traits::type *a) { return pset1(*a); } + +/** \internal \returns a packet with elements of \a *from duplicated. + * For instance, for a packet of 8 elements, 4 scalars will be read from \a *from and + * duplicated to form: {from[0],from[0],from[1],from[1],from[2],from[2],from[3],from[3]} + * Currently, this function is only used for scalar * complex products. + */ +template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet +ploaddup(const typename unpacket_traits::type* from) { return *from; } + +/** \internal \returns a packet with elements of \a *from quadrupled. + * For instance, for a packet of 8 elements, 2 scalars will be read from \a *from and + * replicated to form: {from[0],from[0],from[0],from[0],from[1],from[1],from[1],from[1]} + * Currently, this function is only used in matrix products. + * For packet-size smaller or equal to 4, this function is equivalent to pload1 + */ +template EIGEN_DEVICE_FUNC inline Packet +ploadquad(const typename unpacket_traits::type* from) +{ return pload1(from); } + +/** \internal equivalent to + * \code + * a0 = pload1(a+0); + * a1 = pload1(a+1); + * a2 = pload1(a+2); + * a3 = pload1(a+3); + * \endcode + * \sa pset1, pload1, ploaddup, pbroadcast2 + */ +template EIGEN_DEVICE_FUNC +inline void pbroadcast4(const typename unpacket_traits::type *a, + Packet& a0, Packet& a1, Packet& a2, Packet& a3) +{ + a0 = pload1(a+0); + a1 = pload1(a+1); + a2 = pload1(a+2); + a3 = pload1(a+3); +} + +/** \internal equivalent to + * \code + * a0 = pload1(a+0); + * a1 = pload1(a+1); + * \endcode + * \sa pset1, pload1, ploaddup, pbroadcast4 + */ +template EIGEN_DEVICE_FUNC +inline void pbroadcast2(const typename unpacket_traits::type *a, + Packet& a0, Packet& a1) +{ + a0 = pload1(a+0); + a1 = pload1(a+1); +} + +/** \internal \brief Returns a packet with coefficients (a,a+1,...,a+packet_size-1). */ +template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet +plset(const typename unpacket_traits::type& a) { return a; } + +/** \internal copy the packet \a from to \a *to, \a to must be 16 bytes aligned */ +template EIGEN_DEVICE_FUNC inline void pstore(Scalar* to, const Packet& from) +{ (*to) = from; } + +/** \internal copy the packet \a from to \a *to, (un-aligned store) */ +template EIGEN_DEVICE_FUNC inline void pstoreu(Scalar* to, const Packet& from) +{ (*to) = from; } + + template EIGEN_DEVICE_FUNC inline Packet pgather(const Scalar* from, Index /*stride*/) + { return ploadu(from); } + + template EIGEN_DEVICE_FUNC inline void pscatter(Scalar* to, const Packet& from, Index /*stride*/) + { pstore(to, from); } + +/** \internal tries to do cache prefetching of \a addr */ +template EIGEN_DEVICE_FUNC inline void prefetch(const Scalar* addr) +{ +#ifdef __CUDA_ARCH__ +#if defined(__LP64__) + // 64-bit pointer operand constraint for inlined asm + asm(" prefetch.L1 [ %1 ];" : "=l"(addr) : "l"(addr)); +#else + // 32-bit pointer operand constraint for inlined asm + asm(" prefetch.L1 [ %1 ];" : "=r"(addr) : "r"(addr)); +#endif +#elif (!EIGEN_COMP_MSVC) && (EIGEN_COMP_GNUC || EIGEN_COMP_CLANG || EIGEN_COMP_ICC) + __builtin_prefetch(addr); +#endif +} + +/** \internal \returns the first element of a packet */ +template EIGEN_DEVICE_FUNC inline typename unpacket_traits::type pfirst(const Packet& a) +{ return a; } + +/** \internal \returns a packet where the element i contains the sum of the packet of \a vec[i] */ +template EIGEN_DEVICE_FUNC inline Packet +preduxp(const Packet* vecs) { return vecs[0]; } + +/** \internal \returns the sum of the elements of \a a*/ +template EIGEN_DEVICE_FUNC inline typename unpacket_traits::type predux(const Packet& a) +{ return a; } + +/** \internal \returns the sum of the elements of \a a by block of 4 elements. + * For a packet {a0, a1, a2, a3, a4, a5, a6, a7}, it returns a half packet {a0+a4, a1+a5, a2+a6, a3+a7} + * For packet-size smaller or equal to 4, this boils down to a noop. + */ +template EIGEN_DEVICE_FUNC inline +typename conditional<(unpacket_traits::size%8)==0,typename unpacket_traits::half,Packet>::type +predux_downto4(const Packet& a) +{ return a; } + +/** \internal \returns the product of the elements of \a a*/ +template EIGEN_DEVICE_FUNC inline typename unpacket_traits::type predux_mul(const Packet& a) +{ return a; } + +/** \internal \returns the min of the elements of \a a*/ +template EIGEN_DEVICE_FUNC inline typename unpacket_traits::type predux_min(const Packet& a) +{ return a; } + +/** \internal \returns the max of the elements of \a a*/ +template EIGEN_DEVICE_FUNC inline typename unpacket_traits::type predux_max(const Packet& a) +{ return a; } + +/** \internal \returns the reversed elements of \a a*/ +template EIGEN_DEVICE_FUNC inline Packet preverse(const Packet& a) +{ return a; } + +/** \internal \returns \a a with real and imaginary part flipped (for complex type only) */ +template EIGEN_DEVICE_FUNC inline Packet pcplxflip(const Packet& a) +{ + // FIXME: uncomment the following in case we drop the internal imag and real functions. +// using std::imag; +// using std::real; + return Packet(imag(a),real(a)); +} + +/************************** +* Special math functions +***************************/ + +/** \internal \returns the sine of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet psin(const Packet& a) { using std::sin; return sin(a); } + +/** \internal \returns the cosine of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pcos(const Packet& a) { using std::cos; return cos(a); } + +/** \internal \returns the tan of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet ptan(const Packet& a) { using std::tan; return tan(a); } + +/** \internal \returns the arc sine of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pasin(const Packet& a) { using std::asin; return asin(a); } + +/** \internal \returns the arc cosine of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pacos(const Packet& a) { using std::acos; return acos(a); } + +/** \internal \returns the arc tangent of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet patan(const Packet& a) { using std::atan; return atan(a); } + +/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet psinh(const Packet& a) { using std::sinh; return sinh(a); } + +/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pcosh(const Packet& a) { using std::cosh; return cosh(a); } + +/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet ptanh(const Packet& a) { using std::tanh; return tanh(a); } + +/** \internal \returns the exp of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pexp(const Packet& a) { using std::exp; return exp(a); } + +/** \internal \returns the log of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet plog(const Packet& a) { using std::log; return log(a); } + +/** \internal \returns the log1p of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet plog1p(const Packet& a) { return numext::log1p(a); } + +/** \internal \returns the log10 of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet plog10(const Packet& a) { using std::log10; return log10(a); } + +/** \internal \returns the square-root of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet psqrt(const Packet& a) { using std::sqrt; return sqrt(a); } + +/** \internal \returns the reciprocal square-root of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet prsqrt(const Packet& a) { + return pdiv(pset1(1), psqrt(a)); +} + +/** \internal \returns the rounded value of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pround(const Packet& a) { using numext::round; return round(a); } + +/** \internal \returns the floor of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pfloor(const Packet& a) { using numext::floor; return floor(a); } + +/** \internal \returns the ceil of \a a (coeff-wise) */ +template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS +Packet pceil(const Packet& a) { using numext::ceil; return ceil(a); } + +/*************************************************************************** +* The following functions might not have to be overwritten for vectorized types +***************************************************************************/ + +/** \internal copy a packet with constant coeficient \a a (e.g., [a,a,a,a]) to \a *to. \a to must be 16 bytes aligned */ +// NOTE: this function must really be templated on the packet type (think about different packet types for the same scalar type) +template +inline void pstore1(typename unpacket_traits::type* to, const typename unpacket_traits::type& a) +{ + pstore(to, pset1(a)); +} + +/** \internal \returns a * b + c (coeff-wise) */ +template EIGEN_DEVICE_FUNC inline Packet +pmadd(const Packet& a, + const Packet& b, + const Packet& c) +{ return padd(pmul(a, b),c); } + +/** \internal \returns a packet version of \a *from. + * The pointer \a from must be aligned on a \a Alignment bytes boundary. */ +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits::type* from) +{ + if(Alignment >= unpacket_traits::alignment) + return pload(from); + else + return ploadu(from); +} + +/** \internal copy the packet \a from to \a *to. + * The pointer \a from must be aligned on a \a Alignment bytes boundary. */ +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(Scalar* to, const Packet& from) +{ + if(Alignment >= unpacket_traits::alignment) + pstore(to, from); + else + pstoreu(to, from); +} + +/** \internal \returns a packet version of \a *from. + * Unlike ploadt, ploadt_ro takes advantage of the read-only memory path on the + * hardware if available to speedup the loading of data that won't be modified + * by the current computation. + */ +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro(const typename unpacket_traits::type* from) +{ + return ploadt(from); +} + +/** \internal default implementation of palign() allowing partial specialization */ +template +struct palign_impl +{ + // by default data are aligned, so there is nothing to be done :) + static inline void run(PacketType&, const PacketType&) {} +}; + +/** \internal update \a first using the concatenation of the packet_size minus \a Offset last elements + * of \a first and \a Offset first elements of \a second. + * + * This function is currently only used to optimize matrix-vector products on unligned matrices. + * It takes 2 packets that represent a contiguous memory array, and returns a packet starting + * at the position \a Offset. For instance, for packets of 4 elements, we have: + * Input: + * - first = {f0,f1,f2,f3} + * - second = {s0,s1,s2,s3} + * Output: + * - if Offset==0 then {f0,f1,f2,f3} + * - if Offset==1 then {f1,f2,f3,s0} + * - if Offset==2 then {f2,f3,s0,s1} + * - if Offset==3 then {f3,s0,s1,s3} + */ +template +inline void palign(PacketType& first, const PacketType& second) +{ + palign_impl::run(first,second); +} + +/*************************************************************************** +* Fast complex products (GCC generates a function call which is very slow) +***************************************************************************/ + +// Eigen+CUDA does not support complexes. +#ifndef __CUDACC__ + +template<> inline std::complex pmul(const std::complex& a, const std::complex& b) +{ return std::complex(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); } + +template<> inline std::complex pmul(const std::complex& a, const std::complex& b) +{ return std::complex(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); } + +#endif + + +/*************************************************************************** + * PacketBlock, that is a collection of N packets where the number of words + * in the packet is a multiple of N. +***************************************************************************/ +template ::size> struct PacketBlock { + Packet packet[N]; +}; + +template EIGEN_DEVICE_FUNC inline void +ptranspose(PacketBlock& /*kernel*/) { + // Nothing to do in the scalar case, i.e. a 1x1 matrix. +} + +/*************************************************************************** + * Selector, i.e. vector of N boolean values used to select (i.e. blend) + * words from 2 packets. +***************************************************************************/ +template struct Selector { + bool select[N]; +}; + +template EIGEN_DEVICE_FUNC inline Packet +pblend(const Selector::size>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) { + return ifPacket.select[0] ? thenPacket : elsePacket; +} + +/** \internal \returns \a a with the first coefficient replaced by the scalar b */ +template EIGEN_DEVICE_FUNC inline Packet +pinsertfirst(const Packet& a, typename unpacket_traits::type b) +{ + // Default implementation based on pblend. + // It must be specialized for higher performance. + Selector::size> mask; + mask.select[0] = true; + // This for loop should be optimized away by the compiler. + for(Index i=1; i::size; ++i) + mask.select[i] = false; + return pblend(mask, pset1(b), a); +} + +/** \internal \returns \a a with the last coefficient replaced by the scalar b */ +template EIGEN_DEVICE_FUNC inline Packet +pinsertlast(const Packet& a, typename unpacket_traits::type b) +{ + // Default implementation based on pblend. + // It must be specialized for higher performance. + Selector::size> mask; + // This for loop should be optimized away by the compiler. + for(Index i=0; i::size-1; ++i) + mask.select[i] = false; + mask.select[unpacket_traits::size-1] = true; + return pblend(mask, pset1(b), a); +} + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_GENERIC_PACKET_MATH_H diff --git a/3rdparty/eigen3/Eigen/src/Core/GlobalFunctions.h b/3rdparty/eigen3/Eigen/src/Core/GlobalFunctions.h new file mode 100644 index 0000000..769dc25 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/GlobalFunctions.h @@ -0,0 +1,187 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2010-2016 Gael Guennebaud +// Copyright (C) 2010 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_GLOBAL_FUNCTIONS_H +#define EIGEN_GLOBAL_FUNCTIONS_H + +#ifdef EIGEN_PARSED_BY_DOXYGEN + +#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \ + /** \returns an expression of the coefficient-wise DOC_OP of \a x + + DOC_DETAILS + + \sa Math functions, class CwiseUnaryOp + */ \ + template \ + inline const Eigen::CwiseUnaryOp, const Derived> \ + NAME(const Eigen::ArrayBase& x); + +#else + +#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \ + template \ + inline const Eigen::CwiseUnaryOp, const Derived> \ + (NAME)(const Eigen::ArrayBase& x) { \ + return Eigen::CwiseUnaryOp, const Derived>(x.derived()); \ + } + +#endif // EIGEN_PARSED_BY_DOXYGEN + +#define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \ + \ + template \ + struct NAME##_retval > \ + { \ + typedef const Eigen::CwiseUnaryOp, const Derived> type; \ + }; \ + template \ + struct NAME##_impl > \ + { \ + static inline typename NAME##_retval >::type run(const Eigen::ArrayBase& x) \ + { \ + return typename NAME##_retval >::type(x.derived()); \ + } \ + }; + +namespace Eigen +{ + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(real,scalar_real_op,real part,\sa ArrayBase::real) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(imag,scalar_imag_op,imaginary part,\sa ArrayBase::imag) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(conj,scalar_conjugate_op,complex conjugate,\sa ArrayBase::conjugate) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(inverse,scalar_inverse_op,inverse,\sa ArrayBase::inverse) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sin,scalar_sin_op,sine,\sa ArrayBase::sin) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cos,scalar_cos_op,cosine,\sa ArrayBase::cos) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tan,scalar_tan_op,tangent,\sa ArrayBase::tan) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(atan,scalar_atan_op,arc-tangent,\sa ArrayBase::atan) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asin,scalar_asin_op,arc-sine,\sa ArrayBase::asin) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos,scalar_acos_op,arc-consine,\sa ArrayBase::acos) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sinh,scalar_sinh_op,hyperbolic sine,\sa ArrayBase::sinh) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cosh,scalar_cosh_op,hyperbolic cosine,\sa ArrayBase::cosh) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tanh,scalar_tanh_op,hyperbolic tangent,\sa ArrayBase::tanh) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(lgamma,scalar_lgamma_op,natural logarithm of the gamma function,\sa ArrayBase::lgamma) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(digamma,scalar_digamma_op,derivative of lgamma,\sa ArrayBase::digamma) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erf,scalar_erf_op,error function,\sa ArrayBase::erf) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erfc,scalar_erfc_op,complement error function,\sa ArrayBase::erfc) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(exp,scalar_exp_op,exponential,\sa ArrayBase::exp) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log,scalar_log_op,natural logarithm,\sa Eigen::log10 DOXCOMMA ArrayBase::log) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log1p,scalar_log1p_op,natural logarithm of 1 plus the value,\sa ArrayBase::log1p) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log10,scalar_log10_op,base 10 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs,scalar_abs_op,absolute value,\sa ArrayBase::abs DOXCOMMA MatrixBase::cwiseAbs) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs2,scalar_abs2_op,squared absolute value,\sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(arg,scalar_arg_op,complex argument,\sa ArrayBase::arg) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sqrt,scalar_sqrt_op,square root,\sa ArrayBase::sqrt DOXCOMMA MatrixBase::cwiseSqrt) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(rsqrt,scalar_rsqrt_op,reciprocal square root,\sa ArrayBase::rsqrt) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(square,scalar_square_op,square (power 2),\sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cube,scalar_cube_op,cube (power 3),\sa Eigen::pow DOXCOMMA ArrayBase::cube) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(round,scalar_round_op,nearest integer,\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(floor,scalar_floor_op,nearest integer not greater than the giben value,\sa Eigen::ceil DOXCOMMA ArrayBase::floor) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ceil,scalar_ceil_op,nearest integer not less than the giben value,\sa Eigen::floor DOXCOMMA ArrayBase::ceil) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isnan,scalar_isnan_op,not-a-number test,\sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isinf,scalar_isinf_op,infinite value test,\sa Eigen::isnan DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isinf) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isfinite,scalar_isfinite_op,finite value test,\sa Eigen::isinf DOXCOMMA Eigen::isnan DOXCOMMA ArrayBase::isfinite) + EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sign,scalar_sign_op,sign (or 0),\sa ArrayBase::sign) + + /** \returns an expression of the coefficient-wise power of \a x to the given constant \a exponent. + * + * \tparam ScalarExponent is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression (\c Derived::Scalar). + * + * \sa ArrayBase::pow() + * + * \relates ArrayBase + */ +#ifdef EIGEN_PARSED_BY_DOXYGEN + template + inline const CwiseBinaryOp,Derived,Constant > + pow(const Eigen::ArrayBase& x, const ScalarExponent& exponent); +#else + template + inline typename internal::enable_if< !(internal::is_same::value) && EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent), + const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,ScalarExponent,pow) >::type + pow(const Eigen::ArrayBase& x, const ScalarExponent& exponent) { + return x.derived().pow(exponent); + } + + template + inline const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename Derived::Scalar,pow) + pow(const Eigen::ArrayBase& x, const typename Derived::Scalar& exponent) { + return x.derived().pow(exponent); + } +#endif + + /** \returns an expression of the coefficient-wise power of \a x to the given array of \a exponents. + * + * This function computes the coefficient-wise power. + * + * Example: \include Cwise_array_power_array.cpp + * Output: \verbinclude Cwise_array_power_array.out + * + * \sa ArrayBase::pow() + * + * \relates ArrayBase + */ + template + inline const Eigen::CwiseBinaryOp, const Derived, const ExponentDerived> + pow(const Eigen::ArrayBase& x, const Eigen::ArrayBase& exponents) + { + return Eigen::CwiseBinaryOp, const Derived, const ExponentDerived>( + x.derived(), + exponents.derived() + ); + } + + /** \returns an expression of the coefficient-wise power of the scalar \a x to the given array of \a exponents. + * + * This function computes the coefficient-wise power between a scalar and an array of exponents. + * + * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar). + * + * Example: \include Cwise_scalar_power_array.cpp + * Output: \verbinclude Cwise_scalar_power_array.out + * + * \sa ArrayBase::pow() + * + * \relates ArrayBase + */ +#ifdef EIGEN_PARSED_BY_DOXYGEN + template + inline const CwiseBinaryOp,Constant,Derived> + pow(const Scalar& x,const Eigen::ArrayBase& x); +#else + template + inline typename internal::enable_if< !(internal::is_same::value) && EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar), + const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,Derived,pow) >::type + pow(const Scalar& x, const Eigen::ArrayBase& exponents) + { + return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,Derived,pow)( + typename internal::plain_constant_type::type(exponents.rows(), exponents.cols(), x), exponents.derived() ); + } + + template + inline const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename Derived::Scalar,Derived,pow) + pow(const typename Derived::Scalar& x, const Eigen::ArrayBase& exponents) + { + return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename Derived::Scalar,Derived,pow)( + typename internal::plain_constant_type::type(exponents.rows(), exponents.cols(), x), exponents.derived() ); + } +#endif + + + namespace internal + { + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op) + } +} + +// TODO: cleanly disable those functions that are not supported on Array (numext::real_ref, internal::random, internal::isApprox...) + +#endif // EIGEN_GLOBAL_FUNCTIONS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/IO.h b/3rdparty/eigen3/Eigen/src/Core/IO.h new file mode 100644 index 0000000..da7fd6c --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/IO.h @@ -0,0 +1,225 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2008 Benoit Jacob +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_IO_H +#define EIGEN_IO_H + +namespace Eigen { + +enum { DontAlignCols = 1 }; +enum { StreamPrecision = -1, + FullPrecision = -2 }; + +namespace internal { +template +std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt); +} + +/** \class IOFormat + * \ingroup Core_Module + * + * \brief Stores a set of parameters controlling the way matrices are printed + * + * List of available parameters: + * - \b precision number of digits for floating point values, or one of the special constants \c StreamPrecision and \c FullPrecision. + * The default is the special value \c StreamPrecision which means to use the + * stream's own precision setting, as set for instance using \c cout.precision(3). The other special value + * \c FullPrecision means that the number of digits will be computed to match the full precision of each floating-point + * type. + * - \b flags an OR-ed combination of flags, the default value is 0, the only currently available flag is \c DontAlignCols which + * allows to disable the alignment of columns, resulting in faster code. + * - \b coeffSeparator string printed between two coefficients of the same row + * - \b rowSeparator string printed between two rows + * - \b rowPrefix string printed at the beginning of each row + * - \b rowSuffix string printed at the end of each row + * - \b matPrefix string printed at the beginning of the matrix + * - \b matSuffix string printed at the end of the matrix + * + * Example: \include IOFormat.cpp + * Output: \verbinclude IOFormat.out + * + * \sa DenseBase::format(), class WithFormat + */ +struct IOFormat +{ + /** Default constructor, see class IOFormat for the meaning of the parameters */ + IOFormat(int _precision = StreamPrecision, int _flags = 0, + const std::string& _coeffSeparator = " ", + const std::string& _rowSeparator = "\n", const std::string& _rowPrefix="", const std::string& _rowSuffix="", + const std::string& _matPrefix="", const std::string& _matSuffix="") + : matPrefix(_matPrefix), matSuffix(_matSuffix), rowPrefix(_rowPrefix), rowSuffix(_rowSuffix), rowSeparator(_rowSeparator), + rowSpacer(""), coeffSeparator(_coeffSeparator), precision(_precision), flags(_flags) + { + // TODO check if rowPrefix, rowSuffix or rowSeparator contains a newline + // don't add rowSpacer if columns are not to be aligned + if((flags & DontAlignCols)) + return; + int i = int(matSuffix.length())-1; + while (i>=0 && matSuffix[i]!='\n') + { + rowSpacer += ' '; + i--; + } + } + std::string matPrefix, matSuffix; + std::string rowPrefix, rowSuffix, rowSeparator, rowSpacer; + std::string coeffSeparator; + int precision; + int flags; +}; + +/** \class WithFormat + * \ingroup Core_Module + * + * \brief Pseudo expression providing matrix output with given format + * + * \tparam ExpressionType the type of the object on which IO stream operations are performed + * + * This class represents an expression with stream operators controlled by a given IOFormat. + * It is the return type of DenseBase::format() + * and most of the time this is the only way it is used. + * + * See class IOFormat for some examples. + * + * \sa DenseBase::format(), class IOFormat + */ +template +class WithFormat +{ + public: + + WithFormat(const ExpressionType& matrix, const IOFormat& format) + : m_matrix(matrix), m_format(format) + {} + + friend std::ostream & operator << (std::ostream & s, const WithFormat& wf) + { + return internal::print_matrix(s, wf.m_matrix.eval(), wf.m_format); + } + + protected: + typename ExpressionType::Nested m_matrix; + IOFormat m_format; +}; + +namespace internal { + +// NOTE: This helper is kept for backward compatibility with previous code specializing +// this internal::significant_decimals_impl structure. In the future we should directly +// call digits10() which has been introduced in July 2016 in 3.3. +template +struct significant_decimals_impl +{ + static inline int run() + { + return NumTraits::digits10(); + } +}; + +/** \internal + * print the matrix \a _m to the output stream \a s using the output format \a fmt */ +template +std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt) +{ + if(_m.size() == 0) + { + s << fmt.matPrefix << fmt.matSuffix; + return s; + } + + typename Derived::Nested m = _m; + typedef typename Derived::Scalar Scalar; + + Index width = 0; + + std::streamsize explicit_precision; + if(fmt.precision == StreamPrecision) + { + explicit_precision = 0; + } + else if(fmt.precision == FullPrecision) + { + if (NumTraits::IsInteger) + { + explicit_precision = 0; + } + else + { + explicit_precision = significant_decimals_impl::run(); + } + } + else + { + explicit_precision = fmt.precision; + } + + std::streamsize old_precision = 0; + if(explicit_precision) old_precision = s.precision(explicit_precision); + + bool align_cols = !(fmt.flags & DontAlignCols); + if(align_cols) + { + // compute the largest width + for(Index j = 0; j < m.cols(); ++j) + for(Index i = 0; i < m.rows(); ++i) + { + std::stringstream sstr; + sstr.copyfmt(s); + sstr << m.coeff(i,j); + width = std::max(width, Index(sstr.str().length())); + } + } + s << fmt.matPrefix; + for(Index i = 0; i < m.rows(); ++i) + { + if (i) + s << fmt.rowSpacer; + s << fmt.rowPrefix; + if(width) s.width(width); + s << m.coeff(i, 0); + for(Index j = 1; j < m.cols(); ++j) + { + s << fmt.coeffSeparator; + if (width) s.width(width); + s << m.coeff(i, j); + } + s << fmt.rowSuffix; + if( i < m.rows() - 1) + s << fmt.rowSeparator; + } + s << fmt.matSuffix; + if(explicit_precision) s.precision(old_precision); + return s; +} + +} // end namespace internal + +/** \relates DenseBase + * + * Outputs the matrix, to the given stream. + * + * If you wish to print the matrix with a format different than the default, use DenseBase::format(). + * + * It is also possible to change the default format by defining EIGEN_DEFAULT_IO_FORMAT before including Eigen headers. + * If not defined, this will automatically be defined to Eigen::IOFormat(), that is the Eigen::IOFormat with default parameters. + * + * \sa DenseBase::format() + */ +template +std::ostream & operator << +(std::ostream & s, + const DenseBase & m) +{ + return internal::print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT); +} + +} // end namespace Eigen + +#endif // EIGEN_IO_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Inverse.h b/3rdparty/eigen3/Eigen/src/Core/Inverse.h new file mode 100644 index 0000000..b76f043 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Inverse.h @@ -0,0 +1,118 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2014 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_INVERSE_H +#define EIGEN_INVERSE_H + +namespace Eigen { + +template class InverseImpl; + +namespace internal { + +template +struct traits > + : traits +{ + typedef typename XprType::PlainObject PlainObject; + typedef traits BaseTraits; + enum { + Flags = BaseTraits::Flags & RowMajorBit + }; +}; + +} // end namespace internal + +/** \class Inverse + * + * \brief Expression of the inverse of another expression + * + * \tparam XprType the type of the expression we are taking the inverse + * + * This class represents an abstract expression of A.inverse() + * and most of the time this is the only way it is used. + * + */ +template +class Inverse : public InverseImpl::StorageKind> +{ +public: + typedef typename XprType::StorageIndex StorageIndex; + typedef typename XprType::PlainObject PlainObject; + typedef typename XprType::Scalar Scalar; + typedef typename internal::ref_selector::type XprTypeNested; + typedef typename internal::remove_all::type XprTypeNestedCleaned; + typedef typename internal::ref_selector::type Nested; + typedef typename internal::remove_all::type NestedExpression; + + explicit EIGEN_DEVICE_FUNC Inverse(const XprType &xpr) + : m_xpr(xpr) + {} + + EIGEN_DEVICE_FUNC Index rows() const { return m_xpr.rows(); } + EIGEN_DEVICE_FUNC Index cols() const { return m_xpr.cols(); } + + EIGEN_DEVICE_FUNC const XprTypeNestedCleaned& nestedExpression() const { return m_xpr; } + +protected: + XprTypeNested m_xpr; +}; + +// Generic API dispatcher +template +class InverseImpl + : public internal::generic_xpr_base >::type +{ +public: + typedef typename internal::generic_xpr_base >::type Base; + typedef typename XprType::Scalar Scalar; +private: + + Scalar coeff(Index row, Index col) const; + Scalar coeff(Index i) const; +}; + +namespace internal { + +/** \internal + * \brief Default evaluator for Inverse expression. + * + * This default evaluator for Inverse expression simply evaluate the inverse into a temporary + * by a call to internal::call_assignment_no_alias. + * Therefore, inverse implementers only have to specialize Assignment, ...> for + * there own nested expression. + * + * \sa class Inverse + */ +template +struct unary_evaluator > + : public evaluator::PlainObject> +{ + typedef Inverse InverseType; + typedef typename InverseType::PlainObject PlainObject; + typedef evaluator Base; + + enum { Flags = Base::Flags | EvalBeforeNestingBit }; + + unary_evaluator(const InverseType& inv_xpr) + : m_result(inv_xpr.rows(), inv_xpr.cols()) + { + ::new (static_cast(this)) Base(m_result); + internal::call_assignment_no_alias(m_result, inv_xpr); + } + +protected: + PlainObject m_result; +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_INVERSE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Map.h b/3rdparty/eigen3/Eigen/src/Core/Map.h new file mode 100644 index 0000000..548bf9a --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Map.h @@ -0,0 +1,171 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2007-2010 Benoit Jacob +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_MAP_H +#define EIGEN_MAP_H + +namespace Eigen { + +namespace internal { +template +struct traits > + : public traits +{ + typedef traits TraitsBase; + enum { + PlainObjectTypeInnerSize = ((traits::Flags&RowMajorBit)==RowMajorBit) + ? PlainObjectType::ColsAtCompileTime + : PlainObjectType::RowsAtCompileTime, + + InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0 + ? int(PlainObjectType::InnerStrideAtCompileTime) + : int(StrideType::InnerStrideAtCompileTime), + OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0 + ? (InnerStrideAtCompileTime==Dynamic || PlainObjectTypeInnerSize==Dynamic + ? Dynamic + : int(InnerStrideAtCompileTime) * int(PlainObjectTypeInnerSize)) + : int(StrideType::OuterStrideAtCompileTime), + Alignment = int(MapOptions)&int(AlignedMask), + Flags0 = TraitsBase::Flags & (~NestByRefBit), + Flags = is_lvalue::value ? int(Flags0) : (int(Flags0) & ~LvalueBit) + }; +private: + enum { Options }; // Expressions don't have Options +}; +} + +/** \class Map + * \ingroup Core_Module + * + * \brief A matrix or vector expression mapping an existing array of data. + * + * \tparam PlainObjectType the equivalent matrix type of the mapped data + * \tparam MapOptions specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned. + * The default is \c #Unaligned. + * \tparam StrideType optionally specifies strides. By default, Map assumes the memory layout + * of an ordinary, contiguous array. This can be overridden by specifying strides. + * The type passed here must be a specialization of the Stride template, see examples below. + * + * This class represents a matrix or vector expression mapping an existing array of data. + * It can be used to let Eigen interface without any overhead with non-Eigen data structures, + * such as plain C arrays or structures from other libraries. By default, it assumes that the + * data is laid out contiguously in memory. You can however override this by explicitly specifying + * inner and outer strides. + * + * Here's an example of simply mapping a contiguous array as a \ref TopicStorageOrders "column-major" matrix: + * \include Map_simple.cpp + * Output: \verbinclude Map_simple.out + * + * If you need to map non-contiguous arrays, you can do so by specifying strides: + * + * Here's an example of mapping an array as a vector, specifying an inner stride, that is, the pointer + * increment between two consecutive coefficients. Here, we're specifying the inner stride as a compile-time + * fixed value. + * \include Map_inner_stride.cpp + * Output: \verbinclude Map_inner_stride.out + * + * Here's an example of mapping an array while specifying an outer stride. Here, since we're mapping + * as a column-major matrix, 'outer stride' means the pointer increment between two consecutive columns. + * Here, we're specifying the outer stride as a runtime parameter. Note that here \c OuterStride<> is + * a short version of \c OuterStride because the default template parameter of OuterStride + * is \c Dynamic + * \include Map_outer_stride.cpp + * Output: \verbinclude Map_outer_stride.out + * + * For more details and for an example of specifying both an inner and an outer stride, see class Stride. + * + * \b Tip: to change the array of data mapped by a Map object, you can use the C++ + * placement new syntax: + * + * Example: \include Map_placement_new.cpp + * Output: \verbinclude Map_placement_new.out + * + * This class is the return type of PlainObjectBase::Map() but can also be used directly. + * + * \sa PlainObjectBase::Map(), \ref TopicStorageOrders + */ +template class Map + : public MapBase > +{ + public: + + typedef MapBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Map) + + typedef typename Base::PointerType PointerType; + typedef PointerType PointerArgType; + EIGEN_DEVICE_FUNC + inline PointerType cast_to_pointer_type(PointerArgType ptr) { return ptr; } + + EIGEN_DEVICE_FUNC + inline Index innerStride() const + { + return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1; + } + + EIGEN_DEVICE_FUNC + inline Index outerStride() const + { + return int(StrideType::OuterStrideAtCompileTime) != 0 ? m_stride.outer() + : int(internal::traits::OuterStrideAtCompileTime) != Dynamic ? Index(internal::traits::OuterStrideAtCompileTime) + : IsVectorAtCompileTime ? (this->size() * innerStride()) + : (int(Flags)&RowMajorBit) ? (this->cols() * innerStride()) + : (this->rows() * innerStride()); + } + + /** Constructor in the fixed-size case. + * + * \param dataPtr pointer to the array to map + * \param stride optional Stride object, passing the strides. + */ + EIGEN_DEVICE_FUNC + explicit inline Map(PointerArgType dataPtr, const StrideType& stride = StrideType()) + : Base(cast_to_pointer_type(dataPtr)), m_stride(stride) + { + PlainObjectType::Base::_check_template_params(); + } + + /** Constructor in the dynamic-size vector case. + * + * \param dataPtr pointer to the array to map + * \param size the size of the vector expression + * \param stride optional Stride object, passing the strides. + */ + EIGEN_DEVICE_FUNC + inline Map(PointerArgType dataPtr, Index size, const StrideType& stride = StrideType()) + : Base(cast_to_pointer_type(dataPtr), size), m_stride(stride) + { + PlainObjectType::Base::_check_template_params(); + } + + /** Constructor in the dynamic-size matrix case. + * + * \param dataPtr pointer to the array to map + * \param rows the number of rows of the matrix expression + * \param cols the number of columns of the matrix expression + * \param stride optional Stride object, passing the strides. + */ + EIGEN_DEVICE_FUNC + inline Map(PointerArgType dataPtr, Index rows, Index cols, const StrideType& stride = StrideType()) + : Base(cast_to_pointer_type(dataPtr), rows, cols), m_stride(stride) + { + PlainObjectType::Base::_check_template_params(); + } + + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map) + + protected: + StrideType m_stride; +}; + + +} // end namespace Eigen + +#endif // EIGEN_MAP_H diff --git a/3rdparty/eigen3/Eigen/src/Core/MapBase.h b/3rdparty/eigen3/Eigen/src/Core/MapBase.h new file mode 100644 index 0000000..020f939 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/MapBase.h @@ -0,0 +1,299 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2007-2010 Benoit Jacob +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_MAPBASE_H +#define EIGEN_MAPBASE_H + +#define EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) \ + EIGEN_STATIC_ASSERT((int(internal::evaluator::Flags) & LinearAccessBit) || Derived::IsVectorAtCompileTime, \ + YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT) + +namespace Eigen { + +/** \ingroup Core_Module + * + * \brief Base class for dense Map and Block expression with direct access + * + * This base class provides the const low-level accessors (e.g. coeff, coeffRef) of dense + * Map and Block objects with direct access. + * Typical users do not have to directly deal with this class. + * + * This class can be extended by through the macro plugin \c EIGEN_MAPBASE_PLUGIN. + * See \link TopicCustomizing_Plugins customizing Eigen \endlink for details. + * + * The \c Derived class has to provide the following two methods describing the memory layout: + * \code Index innerStride() const; \endcode + * \code Index outerStride() const; \endcode + * + * \sa class Map, class Block + */ +template class MapBase + : public internal::dense_xpr_base::type +{ + public: + + typedef typename internal::dense_xpr_base::type Base; + enum { + RowsAtCompileTime = internal::traits::RowsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, + SizeAtCompileTime = Base::SizeAtCompileTime + }; + + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; + typedef typename NumTraits::Real RealScalar; + typedef typename internal::conditional< + bool(internal::is_lvalue::value), + Scalar *, + const Scalar *>::type + PointerType; + + using Base::derived; +// using Base::RowsAtCompileTime; +// using Base::ColsAtCompileTime; +// using Base::SizeAtCompileTime; + using Base::MaxRowsAtCompileTime; + using Base::MaxColsAtCompileTime; + using Base::MaxSizeAtCompileTime; + using Base::IsVectorAtCompileTime; + using Base::Flags; + using Base::IsRowMajor; + + using Base::rows; + using Base::cols; + using Base::size; + using Base::coeff; + using Base::coeffRef; + using Base::lazyAssign; + using Base::eval; + + using Base::innerStride; + using Base::outerStride; + using Base::rowStride; + using Base::colStride; + + // bug 217 - compile error on ICC 11.1 + using Base::operator=; + + typedef typename Base::CoeffReturnType CoeffReturnType; + + /** \copydoc DenseBase::rows() */ + EIGEN_DEVICE_FUNC inline Index rows() const { return m_rows.value(); } + /** \copydoc DenseBase::cols() */ + EIGEN_DEVICE_FUNC inline Index cols() const { return m_cols.value(); } + + /** Returns a pointer to the first coefficient of the matrix or vector. + * + * \note When addressing this data, make sure to honor the strides returned by innerStride() and outerStride(). + * + * \sa innerStride(), outerStride() + */ + EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_data; } + + /** \copydoc PlainObjectBase::coeff(Index,Index) const */ + EIGEN_DEVICE_FUNC + inline const Scalar& coeff(Index rowId, Index colId) const + { + return m_data[colId * colStride() + rowId * rowStride()]; + } + + /** \copydoc PlainObjectBase::coeff(Index) const */ + EIGEN_DEVICE_FUNC + inline const Scalar& coeff(Index index) const + { + EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) + return m_data[index * innerStride()]; + } + + /** \copydoc PlainObjectBase::coeffRef(Index,Index) const */ + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index rowId, Index colId) const + { + return this->m_data[colId * colStride() + rowId * rowStride()]; + } + + /** \copydoc PlainObjectBase::coeffRef(Index) const */ + EIGEN_DEVICE_FUNC + inline const Scalar& coeffRef(Index index) const + { + EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) + return this->m_data[index * innerStride()]; + } + + /** \internal */ + template + inline PacketScalar packet(Index rowId, Index colId) const + { + return internal::ploadt + (m_data + (colId * colStride() + rowId * rowStride())); + } + + /** \internal */ + template + inline PacketScalar packet(Index index) const + { + EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) + return internal::ploadt(m_data + index * innerStride()); + } + + /** \internal Constructor for fixed size matrices or vectors */ + EIGEN_DEVICE_FUNC + explicit inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime) + { + EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) + checkSanity(); + } + + /** \internal Constructor for dynamically sized vectors */ + EIGEN_DEVICE_FUNC + inline MapBase(PointerType dataPtr, Index vecSize) + : m_data(dataPtr), + m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)), + m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime)) + { + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) + eigen_assert(vecSize >= 0); + eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize); + checkSanity(); + } + + /** \internal Constructor for dynamically sized matrices */ + EIGEN_DEVICE_FUNC + inline MapBase(PointerType dataPtr, Index rows, Index cols) + : m_data(dataPtr), m_rows(rows), m_cols(cols) + { + eigen_assert( (dataPtr == 0) + || ( rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) + && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols))); + checkSanity(); + } + + #ifdef EIGEN_MAPBASE_PLUGIN + #include EIGEN_MAPBASE_PLUGIN + #endif + + protected: + + template + EIGEN_DEVICE_FUNC + void checkSanity(typename internal::enable_if<(internal::traits::Alignment>0),void*>::type = 0) const + { +#if EIGEN_MAX_ALIGN_BYTES>0 + eigen_assert(( ((internal::UIntPtr(m_data) % internal::traits::Alignment) == 0) + || (cols() * rows() * innerStride() * sizeof(Scalar)) < internal::traits::Alignment ) && "data is not aligned"); +#endif + } + + template + EIGEN_DEVICE_FUNC + void checkSanity(typename internal::enable_if::Alignment==0,void*>::type = 0) const + {} + + PointerType m_data; + const internal::variable_if_dynamic m_rows; + const internal::variable_if_dynamic m_cols; +}; + +/** \ingroup Core_Module + * + * \brief Base class for non-const dense Map and Block expression with direct access + * + * This base class provides the non-const low-level accessors (e.g. coeff and coeffRef) of + * dense Map and Block objects with direct access. + * It inherits MapBase which defines the const variant for reading specific entries. + * + * \sa class Map, class Block + */ +template class MapBase + : public MapBase +{ + typedef MapBase ReadOnlyMapBase; + public: + + typedef MapBase Base; + + typedef typename Base::Scalar Scalar; + typedef typename Base::PacketScalar PacketScalar; + typedef typename Base::StorageIndex StorageIndex; + typedef typename Base::PointerType PointerType; + + using Base::derived; + using Base::rows; + using Base::cols; + using Base::size; + using Base::coeff; + using Base::coeffRef; + + using Base::innerStride; + using Base::outerStride; + using Base::rowStride; + using Base::colStride; + + typedef typename internal::conditional< + internal::is_lvalue::value, + Scalar, + const Scalar + >::type ScalarWithConstIfNotLvalue; + + EIGEN_DEVICE_FUNC + inline const Scalar* data() const { return this->m_data; } + EIGEN_DEVICE_FUNC + inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error + + EIGEN_DEVICE_FUNC + inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col) + { + return this->m_data[col * colStride() + row * rowStride()]; + } + + EIGEN_DEVICE_FUNC + inline ScalarWithConstIfNotLvalue& coeffRef(Index index) + { + EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) + return this->m_data[index * innerStride()]; + } + + template + inline void writePacket(Index row, Index col, const PacketScalar& val) + { + internal::pstoret + (this->m_data + (col * colStride() + row * rowStride()), val); + } + + template + inline void writePacket(Index index, const PacketScalar& val) + { + EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) + internal::pstoret + (this->m_data + index * innerStride(), val); + } + + EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {} + EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {} + EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index cols) : Base(dataPtr, rows, cols) {} + + EIGEN_DEVICE_FUNC + Derived& operator=(const MapBase& other) + { + ReadOnlyMapBase::Base::operator=(other); + return derived(); + } + + // In theory we could simply refer to Base:Base::operator=, but MSVC does not like Base::Base, + // see bugs 821 and 920. + using ReadOnlyMapBase::Base::operator=; +}; + +#undef EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS + +} // end namespace Eigen + +#endif // EIGEN_MAPBASE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/MathFunctions.h b/3rdparty/eigen3/Eigen/src/Core/MathFunctions.h new file mode 100644 index 0000000..6eb974d --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/MathFunctions.h @@ -0,0 +1,1407 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2010 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_MATHFUNCTIONS_H +#define EIGEN_MATHFUNCTIONS_H + +// source: http://www.geom.uiuc.edu/~huberty/math5337/groupe/digits.html +// TODO this should better be moved to NumTraits +#define EIGEN_PI 3.141592653589793238462643383279502884197169399375105820974944592307816406L + + +namespace Eigen { + +// On WINCE, std::abs is defined for int only, so let's defined our own overloads: +// This issue has been confirmed with MSVC 2008 only, but the issue might exist for more recent versions too. +#if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500 +long abs(long x) { return (labs(x)); } +double abs(double x) { return (fabs(x)); } +float abs(float x) { return (fabsf(x)); } +long double abs(long double x) { return (fabsl(x)); } +#endif + +namespace internal { + +/** \internal \class global_math_functions_filtering_base + * + * What it does: + * Defines a typedef 'type' as follows: + * - if type T has a member typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl, then + * global_math_functions_filtering_base::type is a typedef for it. + * - otherwise, global_math_functions_filtering_base::type is a typedef for T. + * + * How it's used: + * To allow to defined the global math functions (like sin...) in certain cases, like the Array expressions. + * When you do sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know + * is that it inherits ArrayBase. So we implement a partial specialization of sin_impl for ArrayBase. + * So we must make sure to use sin_impl > and not sin_impl, otherwise our partial specialization + * won't be used. How does sin know that? That's exactly what global_math_functions_filtering_base tells it. + * + * How it's implemented: + * SFINAE in the style of enable_if. Highly susceptible of breaking compilers. With GCC, it sure does work, but if you replace + * the typename dummy by an integer template parameter, it doesn't work anymore! + */ + +template +struct global_math_functions_filtering_base +{ + typedef T type; +}; + +template struct always_void { typedef void type; }; + +template +struct global_math_functions_filtering_base + ::type + > +{ + typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type; +}; + +#define EIGEN_MATHFUNC_IMPL(func, scalar) Eigen::internal::func##_impl::type> +#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename Eigen::internal::func##_retval::type>::type + +/**************************************************************************** +* Implementation of real * +****************************************************************************/ + +template::IsComplex> +struct real_default_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + return x; + } +}; + +template +struct real_default_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + using std::real; + return real(x); + } +}; + +template struct real_impl : real_default_impl {}; + +#ifdef __CUDA_ARCH__ +template +struct real_impl > +{ + typedef T RealScalar; + EIGEN_DEVICE_FUNC + static inline T run(const std::complex& x) + { + return x.real(); + } +}; +#endif + +template +struct real_retval +{ + typedef typename NumTraits::Real type; +}; + +/**************************************************************************** +* Implementation of imag * +****************************************************************************/ + +template::IsComplex> +struct imag_default_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar&) + { + return RealScalar(0); + } +}; + +template +struct imag_default_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + using std::imag; + return imag(x); + } +}; + +template struct imag_impl : imag_default_impl {}; + +#ifdef __CUDA_ARCH__ +template +struct imag_impl > +{ + typedef T RealScalar; + EIGEN_DEVICE_FUNC + static inline T run(const std::complex& x) + { + return x.imag(); + } +}; +#endif + +template +struct imag_retval +{ + typedef typename NumTraits::Real type; +}; + +/**************************************************************************** +* Implementation of real_ref * +****************************************************************************/ + +template +struct real_ref_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar& run(Scalar& x) + { + return reinterpret_cast(&x)[0]; + } + EIGEN_DEVICE_FUNC + static inline const RealScalar& run(const Scalar& x) + { + return reinterpret_cast(&x)[0]; + } +}; + +template +struct real_ref_retval +{ + typedef typename NumTraits::Real & type; +}; + +/**************************************************************************** +* Implementation of imag_ref * +****************************************************************************/ + +template +struct imag_ref_default_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar& run(Scalar& x) + { + return reinterpret_cast(&x)[1]; + } + EIGEN_DEVICE_FUNC + static inline const RealScalar& run(const Scalar& x) + { + return reinterpret_cast(&x)[1]; + } +}; + +template +struct imag_ref_default_impl +{ + EIGEN_DEVICE_FUNC + static inline Scalar run(Scalar&) + { + return Scalar(0); + } + EIGEN_DEVICE_FUNC + static inline const Scalar run(const Scalar&) + { + return Scalar(0); + } +}; + +template +struct imag_ref_impl : imag_ref_default_impl::IsComplex> {}; + +template +struct imag_ref_retval +{ + typedef typename NumTraits::Real & type; +}; + +/**************************************************************************** +* Implementation of conj * +****************************************************************************/ + +template::IsComplex> +struct conj_impl +{ + EIGEN_DEVICE_FUNC + static inline Scalar run(const Scalar& x) + { + return x; + } +}; + +template +struct conj_impl +{ + EIGEN_DEVICE_FUNC + static inline Scalar run(const Scalar& x) + { + using std::conj; + return conj(x); + } +}; + +template +struct conj_retval +{ + typedef Scalar type; +}; + +/**************************************************************************** +* Implementation of abs2 * +****************************************************************************/ + +template +struct abs2_impl_default +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + return x*x; + } +}; + +template +struct abs2_impl_default // IsComplex +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + return real(x)*real(x) + imag(x)*imag(x); + } +}; + +template +struct abs2_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + return abs2_impl_default::IsComplex>::run(x); + } +}; + +template +struct abs2_retval +{ + typedef typename NumTraits::Real type; +}; + +/**************************************************************************** +* Implementation of norm1 * +****************************************************************************/ + +template +struct norm1_default_impl +{ + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + EIGEN_USING_STD_MATH(abs); + return abs(real(x)) + abs(imag(x)); + } +}; + +template +struct norm1_default_impl +{ + EIGEN_DEVICE_FUNC + static inline Scalar run(const Scalar& x) + { + EIGEN_USING_STD_MATH(abs); + return abs(x); + } +}; + +template +struct norm1_impl : norm1_default_impl::IsComplex> {}; + +template +struct norm1_retval +{ + typedef typename NumTraits::Real type; +}; + +/**************************************************************************** +* Implementation of hypot * +****************************************************************************/ + +template struct hypot_impl; + +template +struct hypot_retval +{ + typedef typename NumTraits::Real type; +}; + +/**************************************************************************** +* Implementation of cast * +****************************************************************************/ + +template +struct cast_impl +{ + EIGEN_DEVICE_FUNC + static inline NewType run(const OldType& x) + { + return static_cast(x); + } +}; + +// here, for once, we're plainly returning NewType: we don't want cast to do weird things. + +template +EIGEN_DEVICE_FUNC +inline NewType cast(const OldType& x) +{ + return cast_impl::run(x); +} + +/**************************************************************************** +* Implementation of round * +****************************************************************************/ + +#if EIGEN_HAS_CXX11_MATH + template + struct round_impl { + static inline Scalar run(const Scalar& x) + { + EIGEN_STATIC_ASSERT((!NumTraits::IsComplex), NUMERIC_TYPE_MUST_BE_REAL) + using std::round; + return round(x); + } + }; +#else + template + struct round_impl + { + static inline Scalar run(const Scalar& x) + { + EIGEN_STATIC_ASSERT((!NumTraits::IsComplex), NUMERIC_TYPE_MUST_BE_REAL) + EIGEN_USING_STD_MATH(floor); + EIGEN_USING_STD_MATH(ceil); + return (x > Scalar(0)) ? floor(x + Scalar(0.5)) : ceil(x - Scalar(0.5)); + } + }; +#endif + +template +struct round_retval +{ + typedef Scalar type; +}; + +/**************************************************************************** +* Implementation of arg * +****************************************************************************/ + +#if EIGEN_HAS_CXX11_MATH + template + struct arg_impl { + static inline Scalar run(const Scalar& x) + { + EIGEN_USING_STD_MATH(arg); + return arg(x); + } + }; +#else + template::IsComplex> + struct arg_default_impl + { + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + return (x < Scalar(0)) ? Scalar(EIGEN_PI) : Scalar(0); } + }; + + template + struct arg_default_impl + { + typedef typename NumTraits::Real RealScalar; + EIGEN_DEVICE_FUNC + static inline RealScalar run(const Scalar& x) + { + EIGEN_USING_STD_MATH(arg); + return arg(x); + } + }; + + template struct arg_impl : arg_default_impl {}; +#endif + +template +struct arg_retval +{ + typedef typename NumTraits::Real type; +}; + +/**************************************************************************** +* Implementation of log1p * +****************************************************************************/ + +namespace std_fallback { + // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar, + // or that there is no suitable std::log1p function available + template + EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) { + EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar) + typedef typename NumTraits::Real RealScalar; + EIGEN_USING_STD_MATH(log); + Scalar x1p = RealScalar(1) + x; + return numext::equal_strict(x1p, Scalar(1)) ? x : x * ( log(x1p) / (x1p - RealScalar(1)) ); + } +} + +template +struct log1p_impl { + static inline Scalar run(const Scalar& x) + { + EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar) + #if EIGEN_HAS_CXX11_MATH + using std::log1p; + #endif + using std_fallback::log1p; + return log1p(x); + } +}; + + +template +struct log1p_retval +{ + typedef Scalar type; +}; + +/**************************************************************************** +* Implementation of pow * +****************************************************************************/ + +template::IsInteger&&NumTraits::IsInteger> +struct pow_impl +{ + //typedef Scalar retval; + typedef typename ScalarBinaryOpTraits >::ReturnType result_type; + static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y) + { + EIGEN_USING_STD_MATH(pow); + return pow(x, y); + } +}; + +template +struct pow_impl +{ + typedef ScalarX result_type; + static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y) + { + ScalarX res(1); + eigen_assert(!NumTraits::IsSigned || y >= 0); + if(y & 1) res *= x; + y >>= 1; + while(y) + { + x *= x; + if(y&1) res *= x; + y >>= 1; + } + return res; + } +}; + +/**************************************************************************** +* Implementation of random * +****************************************************************************/ + +template +struct random_default_impl {}; + +template +struct random_impl : random_default_impl::IsComplex, NumTraits::IsInteger> {}; + +template +struct random_retval +{ + typedef Scalar type; +}; + +template inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y); +template inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(); + +template +struct random_default_impl +{ + static inline Scalar run(const Scalar& x, const Scalar& y) + { + return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX); + } + static inline Scalar run() + { + return run(Scalar(NumTraits::IsSigned ? -1 : 0), Scalar(1)); + } +}; + +enum { + meta_floor_log2_terminate, + meta_floor_log2_move_up, + meta_floor_log2_move_down, + meta_floor_log2_bogus +}; + +template struct meta_floor_log2_selector +{ + enum { middle = (lower + upper) / 2, + value = (upper <= lower + 1) ? int(meta_floor_log2_terminate) + : (n < (1 << middle)) ? int(meta_floor_log2_move_down) + : (n==0) ? int(meta_floor_log2_bogus) + : int(meta_floor_log2_move_up) + }; +}; + +template::value> +struct meta_floor_log2 {}; + +template +struct meta_floor_log2 +{ + enum { value = meta_floor_log2::middle>::value }; +}; + +template +struct meta_floor_log2 +{ + enum { value = meta_floor_log2::middle, upper>::value }; +}; + +template +struct meta_floor_log2 +{ + enum { value = (n >= ((unsigned int)(1) << (lower+1))) ? lower+1 : lower }; +}; + +template +struct meta_floor_log2 +{ + // no value, error at compile time +}; + +template +struct random_default_impl +{ + static inline Scalar run(const Scalar& x, const Scalar& y) + { + typedef typename conditional::IsSigned,std::ptrdiff_t,std::size_t>::type ScalarX; + if(y=x the result converted to an unsigned long is still correct. + std::size_t range = ScalarX(y)-ScalarX(x); + std::size_t offset = 0; + // rejection sampling + std::size_t divisor = 1; + std::size_t multiplier = 1; + if(range range); + return Scalar(ScalarX(x) + offset); + } + + static inline Scalar run() + { +#ifdef EIGEN_MAKING_DOCS + return run(Scalar(NumTraits::IsSigned ? -10 : 0), Scalar(10)); +#else + enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value, + scalar_bits = sizeof(Scalar) * CHAR_BIT, + shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)), + offset = NumTraits::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0 + }; + return Scalar((std::rand() >> shift) - offset); +#endif + } +}; + +template +struct random_default_impl +{ + static inline Scalar run(const Scalar& x, const Scalar& y) + { + return Scalar(random(real(x), real(y)), + random(imag(x), imag(y))); + } + static inline Scalar run() + { + typedef typename NumTraits::Real RealScalar; + return Scalar(random(), random()); + } +}; + +template +inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y) +{ + return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y); +} + +template +inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random() +{ + return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(); +} + +// Implementatin of is* functions + +// std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang. +#if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG) +#define EIGEN_USE_STD_FPCLASSIFY 1 +#else +#define EIGEN_USE_STD_FPCLASSIFY 0 +#endif + +template +EIGEN_DEVICE_FUNC +typename internal::enable_if::value,bool>::type +isnan_impl(const T&) { return false; } + +template +EIGEN_DEVICE_FUNC +typename internal::enable_if::value,bool>::type +isinf_impl(const T&) { return false; } + +template +EIGEN_DEVICE_FUNC +typename internal::enable_if::value,bool>::type +isfinite_impl(const T&) { return true; } + +template +EIGEN_DEVICE_FUNC +typename internal::enable_if<(!internal::is_integral::value)&&(!NumTraits::IsComplex),bool>::type +isfinite_impl(const T& x) +{ + #ifdef __CUDA_ARCH__ + return (::isfinite)(x); + #elif EIGEN_USE_STD_FPCLASSIFY + using std::isfinite; + return isfinite EIGEN_NOT_A_MACRO (x); + #else + return x<=NumTraits::highest() && x>=NumTraits::lowest(); + #endif +} + +template +EIGEN_DEVICE_FUNC +typename internal::enable_if<(!internal::is_integral::value)&&(!NumTraits::IsComplex),bool>::type +isinf_impl(const T& x) +{ + #ifdef __CUDA_ARCH__ + return (::isinf)(x); + #elif EIGEN_USE_STD_FPCLASSIFY + using std::isinf; + return isinf EIGEN_NOT_A_MACRO (x); + #else + return x>NumTraits::highest() || x::lowest(); + #endif +} + +template +EIGEN_DEVICE_FUNC +typename internal::enable_if<(!internal::is_integral::value)&&(!NumTraits::IsComplex),bool>::type +isnan_impl(const T& x) +{ + #ifdef __CUDA_ARCH__ + return (::isnan)(x); + #elif EIGEN_USE_STD_FPCLASSIFY + using std::isnan; + return isnan EIGEN_NOT_A_MACRO (x); + #else + return x != x; + #endif +} + +#if (!EIGEN_USE_STD_FPCLASSIFY) + +#if EIGEN_COMP_MSVC + +template EIGEN_DEVICE_FUNC bool isinf_msvc_helper(T x) +{ + return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF; +} + +//MSVC defines a _isnan builtin function, but for double only +EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return _isnan(x)!=0; } +EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x) { return _isnan(x)!=0; } +EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x) { return _isnan(x)!=0; } + +EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return isinf_msvc_helper(x); } +EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x) { return isinf_msvc_helper(x); } +EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x) { return isinf_msvc_helper(x); } + +#elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC) + +#if EIGEN_GNUC_AT_LEAST(5,0) + #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only"))) +#else + // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol), + // while the second prevent too aggressive optimizations in fast-math mode: + #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only"))) +#endif + +template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const long double& x) { return __builtin_isnan(x); } +template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const double& x) { return __builtin_isnan(x); } +template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const float& x) { return __builtin_isnan(x); } +template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const double& x) { return __builtin_isinf(x); } +template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const float& x) { return __builtin_isinf(x); } +template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const long double& x) { return __builtin_isinf(x); } + +#undef EIGEN_TMP_NOOPT_ATTRIB + +#endif + +#endif + +// The following overload are defined at the end of this file +template EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex& x); +template EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex& x); +template EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex& x); + +template T generic_fast_tanh_float(const T& a_x); + +} // end namespace internal + +/**************************************************************************** +* Generic math functions * +****************************************************************************/ + +namespace numext { + +#ifndef __CUDA_ARCH__ +template +EIGEN_DEVICE_FUNC +EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y) +{ + EIGEN_USING_STD_MATH(min); + return min EIGEN_NOT_A_MACRO (x,y); +} + +template +EIGEN_DEVICE_FUNC +EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y) +{ + EIGEN_USING_STD_MATH(max); + return max EIGEN_NOT_A_MACRO (x,y); +} +#else +template +EIGEN_DEVICE_FUNC +EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y) +{ + return y < x ? y : x; +} +template<> +EIGEN_DEVICE_FUNC +EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y) +{ + return fminf(x, y); +} +template +EIGEN_DEVICE_FUNC +EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y) +{ + return x < y ? y : x; +} +template<> +EIGEN_DEVICE_FUNC +EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y) +{ + return fmaxf(x, y); +} +#endif + + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar& x) +{ + return internal::real_ref_impl::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar& x) +{ + return internal::imag_ref_impl::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y) +{ + return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y); +} + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float log1p(const float &x) { return ::log1pf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double log1p(const double &x) { return ::log1p(x); } +#endif + +template +EIGEN_DEVICE_FUNC +inline typename internal::pow_impl::result_type pow(const ScalarX& x, const ScalarY& y) +{ + return internal::pow_impl::run(x, y); +} + +template EIGEN_DEVICE_FUNC bool (isnan) (const T &x) { return internal::isnan_impl(x); } +template EIGEN_DEVICE_FUNC bool (isinf) (const T &x) { return internal::isinf_impl(x); } +template EIGEN_DEVICE_FUNC bool (isfinite)(const T &x) { return internal::isfinite_impl(x); } + +template +EIGEN_DEVICE_FUNC +inline EIGEN_MATHFUNC_RETVAL(round, Scalar) round(const Scalar& x) +{ + return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x); +} + +template +EIGEN_DEVICE_FUNC +T (floor)(const T& x) +{ + EIGEN_USING_STD_MATH(floor); + return floor(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float floor(const float &x) { return ::floorf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double floor(const double &x) { return ::floor(x); } +#endif + +template +EIGEN_DEVICE_FUNC +T (ceil)(const T& x) +{ + EIGEN_USING_STD_MATH(ceil); + return ceil(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float ceil(const float &x) { return ::ceilf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double ceil(const double &x) { return ::ceil(x); } +#endif + + +/** Log base 2 for 32 bits positive integers. + * Conveniently returns 0 for x==0. */ +inline int log2(int x) +{ + eigen_assert(x>=0); + unsigned int v(x); + static const int table[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + return table[(v * 0x07C4ACDDU) >> 27]; +} + +/** \returns the square root of \a x. + * + * It is essentially equivalent to \code using std::sqrt; return sqrt(x); \endcode, + * but slightly faster for float/double and some compilers (e.g., gcc), thanks to + * specializations when SSE is enabled. + * + * It's usage is justified in performance critical functions, like norm/normalize. + */ +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T sqrt(const T &x) +{ + EIGEN_USING_STD_MATH(sqrt); + return sqrt(x); +} + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T log(const T &x) { + EIGEN_USING_STD_MATH(log); + return log(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float log(const float &x) { return ::logf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double log(const double &x) { return ::log(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +typename internal::enable_if::IsSigned || NumTraits::IsComplex,typename NumTraits::Real>::type +abs(const T &x) { + EIGEN_USING_STD_MATH(abs); + return abs(x); +} + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +typename internal::enable_if::IsSigned || NumTraits::IsComplex),typename NumTraits::Real>::type +abs(const T &x) { + return x; +} + +#if defined(__SYCL_DEVICE_ONLY__) +EIGEN_ALWAYS_INLINE float abs(float x) { return cl::sycl::fabs(x); } +EIGEN_ALWAYS_INLINE double abs(double x) { return cl::sycl::fabs(x); } +#endif // defined(__SYCL_DEVICE_ONLY__) + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float abs(const float &x) { return ::fabsf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double abs(const double &x) { return ::fabs(x); } + +template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float abs(const std::complex& x) { + return ::hypotf(x.real(), x.imag()); +} + +template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double abs(const std::complex& x) { + return ::hypot(x.real(), x.imag()); +} +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T exp(const T &x) { + EIGEN_USING_STD_MATH(exp); + return exp(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float exp(const float &x) { return ::expf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double exp(const double &x) { return ::exp(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T cos(const T &x) { + EIGEN_USING_STD_MATH(cos); + return cos(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float cos(const float &x) { return ::cosf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double cos(const double &x) { return ::cos(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T sin(const T &x) { + EIGEN_USING_STD_MATH(sin); + return sin(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float sin(const float &x) { return ::sinf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double sin(const double &x) { return ::sin(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T tan(const T &x) { + EIGEN_USING_STD_MATH(tan); + return tan(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float tan(const float &x) { return ::tanf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double tan(const double &x) { return ::tan(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T acos(const T &x) { + EIGEN_USING_STD_MATH(acos); + return acos(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float acos(const float &x) { return ::acosf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double acos(const double &x) { return ::acos(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T asin(const T &x) { + EIGEN_USING_STD_MATH(asin); + return asin(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float asin(const float &x) { return ::asinf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double asin(const double &x) { return ::asin(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T atan(const T &x) { + EIGEN_USING_STD_MATH(atan); + return atan(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float atan(const float &x) { return ::atanf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double atan(const double &x) { return ::atan(x); } +#endif + + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T cosh(const T &x) { + EIGEN_USING_STD_MATH(cosh); + return cosh(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float cosh(const float &x) { return ::coshf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double cosh(const double &x) { return ::cosh(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T sinh(const T &x) { + EIGEN_USING_STD_MATH(sinh); + return sinh(x); +} + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float sinh(const float &x) { return ::sinhf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double sinh(const double &x) { return ::sinh(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T tanh(const T &x) { + EIGEN_USING_STD_MATH(tanh); + return tanh(x); +} + +#if (!defined(__CUDACC__)) && EIGEN_FAST_MATH +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float tanh(float x) { return internal::generic_fast_tanh_float(x); } +#endif + +#ifdef __CUDACC__ +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float tanh(const float &x) { return ::tanhf(x); } + +template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double tanh(const double &x) { return ::tanh(x); } +#endif + +template +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +T fmod(const T& a, const T& b) { + EIGEN_USING_STD_MATH(fmod); + return fmod(a, b); +} + +#ifdef __CUDACC__ +template <> +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +float fmod(const float& a, const float& b) { + return ::fmodf(a, b); +} + +template <> +EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE +double fmod(const double& a, const double& b) { + return ::fmod(a, b); +} +#endif + +} // end namespace numext + +namespace internal { + +template +EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex& x) +{ + return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x)); +} + +template +EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex& x) +{ + return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x)); +} + +template +EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex& x) +{ + return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x)); +} + +/**************************************************************************** +* Implementation of fuzzy comparisons * +****************************************************************************/ + +template +struct scalar_fuzzy_default_impl {}; + +template +struct scalar_fuzzy_default_impl +{ + typedef typename NumTraits::Real RealScalar; + template EIGEN_DEVICE_FUNC + static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec) + { + return numext::abs(x) <= numext::abs(y) * prec; + } + EIGEN_DEVICE_FUNC + static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec) + { + return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec; + } + EIGEN_DEVICE_FUNC + static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec) + { + return x <= y || isApprox(x, y, prec); + } +}; + +template +struct scalar_fuzzy_default_impl +{ + typedef typename NumTraits::Real RealScalar; + template EIGEN_DEVICE_FUNC + static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&) + { + return x == Scalar(0); + } + EIGEN_DEVICE_FUNC + static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar&) + { + return x == y; + } + EIGEN_DEVICE_FUNC + static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar&) + { + return x <= y; + } +}; + +template +struct scalar_fuzzy_default_impl +{ + typedef typename NumTraits::Real RealScalar; + template EIGEN_DEVICE_FUNC + static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec) + { + return numext::abs2(x) <= numext::abs2(y) * prec * prec; + } + EIGEN_DEVICE_FUNC + static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec) + { + return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec; + } +}; + +template +struct scalar_fuzzy_impl : scalar_fuzzy_default_impl::IsComplex, NumTraits::IsInteger> {}; + +template EIGEN_DEVICE_FUNC +inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, + const typename NumTraits::Real &precision = NumTraits::dummy_precision()) +{ + return scalar_fuzzy_impl::template isMuchSmallerThan(x, y, precision); +} + +template EIGEN_DEVICE_FUNC +inline bool isApprox(const Scalar& x, const Scalar& y, + const typename NumTraits::Real &precision = NumTraits::dummy_precision()) +{ + return scalar_fuzzy_impl::isApprox(x, y, precision); +} + +template EIGEN_DEVICE_FUNC +inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, + const typename NumTraits::Real &precision = NumTraits::dummy_precision()) +{ + return scalar_fuzzy_impl::isApproxOrLessThan(x, y, precision); +} + +/****************************************** +*** The special case of the bool type *** +******************************************/ + +template<> struct random_impl +{ + static inline bool run() + { + return random(0,1)==0 ? false : true; + } +}; + +template<> struct scalar_fuzzy_impl +{ + typedef bool RealScalar; + + template EIGEN_DEVICE_FUNC + static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&) + { + return !x; + } + + EIGEN_DEVICE_FUNC + static inline bool isApprox(bool x, bool y, bool) + { + return x == y; + } + + EIGEN_DEVICE_FUNC + static inline bool isApproxOrLessThan(const bool& x, const bool& y, const bool&) + { + return (!x) || y; + } + +}; + + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_MATHFUNCTIONS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/MathFunctionsImpl.h b/3rdparty/eigen3/Eigen/src/Core/MathFunctionsImpl.h new file mode 100644 index 0000000..9c1ceb0 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/MathFunctionsImpl.h @@ -0,0 +1,101 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com) +// Copyright (C) 2016 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_MATHFUNCTIONSIMPL_H +#define EIGEN_MATHFUNCTIONSIMPL_H + +namespace Eigen { + +namespace internal { + +/** \internal \returns the hyperbolic tan of \a a (coeff-wise) + Doesn't do anything fancy, just a 13/6-degree rational interpolant which + is accurate up to a couple of ulp in the range [-9, 9], outside of which + the tanh(x) = +/-1. + + This implementation works on both scalars and packets. +*/ +template +T generic_fast_tanh_float(const T& a_x) +{ + // Clamp the inputs to the range [-9, 9] since anything outside + // this range is +/-1.0f in single-precision. + const T plus_9 = pset1(9.f); + const T minus_9 = pset1(-9.f); + // NOTE GCC prior to 6.3 might improperly optimize this max/min + // step such that if a_x is nan, x will be either 9 or -9, + // and tanh will return 1 or -1 instead of nan. + // This is supposed to be fixed in gcc6.3, + // see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867 + const T x = pmax(minus_9,pmin(plus_9,a_x)); + // The monomial coefficients of the numerator polynomial (odd). + const T alpha_1 = pset1(4.89352455891786e-03f); + const T alpha_3 = pset1(6.37261928875436e-04f); + const T alpha_5 = pset1(1.48572235717979e-05f); + const T alpha_7 = pset1(5.12229709037114e-08f); + const T alpha_9 = pset1(-8.60467152213735e-11f); + const T alpha_11 = pset1(2.00018790482477e-13f); + const T alpha_13 = pset1(-2.76076847742355e-16f); + + // The monomial coefficients of the denominator polynomial (even). + const T beta_0 = pset1(4.89352518554385e-03f); + const T beta_2 = pset1(2.26843463243900e-03f); + const T beta_4 = pset1(1.18534705686654e-04f); + const T beta_6 = pset1(1.19825839466702e-06f); + + // Since the polynomials are odd/even, we need x^2. + const T x2 = pmul(x, x); + + // Evaluate the numerator polynomial p. + T p = pmadd(x2, alpha_13, alpha_11); + p = pmadd(x2, p, alpha_9); + p = pmadd(x2, p, alpha_7); + p = pmadd(x2, p, alpha_5); + p = pmadd(x2, p, alpha_3); + p = pmadd(x2, p, alpha_1); + p = pmul(x, p); + + // Evaluate the denominator polynomial p. + T q = pmadd(x2, beta_6, beta_4); + q = pmadd(x2, q, beta_2); + q = pmadd(x2, q, beta_0); + + // Divide the numerator by the denominator. + return pdiv(p, q); +} + +template +EIGEN_STRONG_INLINE +RealScalar positive_real_hypot(const RealScalar& x, const RealScalar& y) +{ + EIGEN_USING_STD_MATH(sqrt); + RealScalar p, qp; + p = numext::maxi(x,y); + if(p==RealScalar(0)) return RealScalar(0); + qp = numext::mini(y,x) / p; + return p * sqrt(RealScalar(1) + qp*qp); +} + +template +struct hypot_impl +{ + typedef typename NumTraits::Real RealScalar; + static inline RealScalar run(const Scalar& x, const Scalar& y) + { + EIGEN_USING_STD_MATH(abs); + return positive_real_hypot(abs(x), abs(y)); + } +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_MATHFUNCTIONSIMPL_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Matrix.h b/3rdparty/eigen3/Eigen/src/Core/Matrix.h new file mode 100644 index 0000000..90c336d --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Matrix.h @@ -0,0 +1,461 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2010 Benoit Jacob +// Copyright (C) 2008-2009 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_MATRIX_H +#define EIGEN_MATRIX_H + +namespace Eigen { + +namespace internal { +template +struct traits > +{ +private: + enum { size = internal::size_at_compile_time<_Rows,_Cols>::ret }; + typedef typename find_best_packet<_Scalar,size>::type PacketScalar; + enum { + row_major_bit = _Options&RowMajor ? RowMajorBit : 0, + is_dynamic_size_storage = _MaxRows==Dynamic || _MaxCols==Dynamic, + max_size = is_dynamic_size_storage ? Dynamic : _MaxRows*_MaxCols, + default_alignment = compute_default_alignment<_Scalar,max_size>::value, + actual_alignment = ((_Options&DontAlign)==0) ? default_alignment : 0, + required_alignment = unpacket_traits::alignment, + packet_access_bit = (packet_traits<_Scalar>::Vectorizable && (EIGEN_UNALIGNED_VECTORIZE || (actual_alignment>=required_alignment))) ? PacketAccessBit : 0 + }; + +public: + typedef _Scalar Scalar; + typedef Dense StorageKind; + typedef Eigen::Index StorageIndex; + typedef MatrixXpr XprKind; + enum { + RowsAtCompileTime = _Rows, + ColsAtCompileTime = _Cols, + MaxRowsAtCompileTime = _MaxRows, + MaxColsAtCompileTime = _MaxCols, + Flags = compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret, + Options = _Options, + InnerStrideAtCompileTime = 1, + OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime, + + // FIXME, the following flag in only used to define NeedsToAlign in PlainObjectBase + EvaluatorFlags = LinearAccessBit | DirectAccessBit | packet_access_bit | row_major_bit, + Alignment = actual_alignment + }; +}; +} + +/** \class Matrix + * \ingroup Core_Module + * + * \brief The matrix class, also used for vectors and row-vectors + * + * The %Matrix class is the work-horse for all \em dense (\ref dense "note") matrices and vectors within Eigen. + * Vectors are matrices with one column, and row-vectors are matrices with one row. + * + * The %Matrix class encompasses \em both fixed-size and dynamic-size objects (\ref fixedsize "note"). + * + * The first three template parameters are required: + * \tparam _Scalar Numeric type, e.g. float, double, int or std::complex. + * User defined scalar types are supported as well (see \ref user_defined_scalars "here"). + * \tparam _Rows Number of rows, or \b Dynamic + * \tparam _Cols Number of columns, or \b Dynamic + * + * The remaining template parameters are optional -- in most cases you don't have to worry about them. + * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of either + * \b #AutoAlign or \b #DontAlign. + * The former controls \ref TopicStorageOrders "storage order", and defaults to column-major. The latter controls alignment, which is required + * for vectorization. It defaults to aligning matrices except for fixed sizes that aren't a multiple of the packet size. + * \tparam _MaxRows Maximum number of rows. Defaults to \a _Rows (\ref maxrows "note"). + * \tparam _MaxCols Maximum number of columns. Defaults to \a _Cols (\ref maxrows "note"). + * + * Eigen provides a number of typedefs covering the usual cases. Here are some examples: + * + * \li \c Matrix2d is a 2x2 square matrix of doubles (\c Matrix) + * \li \c Vector4f is a vector of 4 floats (\c Matrix) + * \li \c RowVector3i is a row-vector of 3 ints (\c Matrix) + * + * \li \c MatrixXf is a dynamic-size matrix of floats (\c Matrix) + * \li \c VectorXf is a dynamic-size vector of floats (\c Matrix) + * + * \li \c Matrix2Xf is a partially fixed-size (dynamic-size) matrix of floats (\c Matrix) + * \li \c MatrixX3d is a partially dynamic-size (fixed-size) matrix of double (\c Matrix) + * + * See \link matrixtypedefs this page \endlink for a complete list of predefined \em %Matrix and \em Vector typedefs. + * + * You can access elements of vectors and matrices using normal subscripting: + * + * \code + * Eigen::VectorXd v(10); + * v[0] = 0.1; + * v[1] = 0.2; + * v(0) = 0.3; + * v(1) = 0.4; + * + * Eigen::MatrixXi m(10, 10); + * m(0, 1) = 1; + * m(0, 2) = 2; + * m(0, 3) = 3; + * \endcode + * + * This class can be extended with the help of the plugin mechanism described on the page + * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIX_PLUGIN. + * + * Some notes: + * + *
    + *
    \anchor dense Dense versus sparse:
    + *
    This %Matrix class handles dense, not sparse matrices and vectors. For sparse matrices and vectors, see the Sparse module. + * + * Dense matrices and vectors are plain usual arrays of coefficients. All the coefficients are stored, in an ordinary contiguous array. + * This is unlike Sparse matrices and vectors where the coefficients are stored as a list of nonzero coefficients.
    + * + *
    \anchor fixedsize Fixed-size versus dynamic-size:
    + *
    Fixed-size means that the numbers of rows and columns are known are compile-time. In this case, Eigen allocates the array + * of coefficients as a fixed-size array, as a class member. This makes sense for very small matrices, typically up to 4x4, sometimes up + * to 16x16. Larger matrices should be declared as dynamic-size even if one happens to know their size at compile-time. + * + * Dynamic-size means that the numbers of rows or columns are not necessarily known at compile-time. In this case they are runtime + * variables, and the array of coefficients is allocated dynamically on the heap. + * + * Note that \em dense matrices, be they Fixed-size or Dynamic-size, do not expand dynamically in the sense of a std::map. + * If you want this behavior, see the Sparse module.
    + * + *
    \anchor maxrows _MaxRows and _MaxCols:
    + *
    In most cases, one just leaves these parameters to the default values. + * These parameters mean the maximum size of rows and columns that the matrix may have. They are useful in cases + * when the exact numbers of rows and columns are not known are compile-time, but it is known at compile-time that they cannot + * exceed a certain value. This happens when taking dynamic-size blocks inside fixed-size matrices: in this case _MaxRows and _MaxCols + * are the dimensions of the original matrix, while _Rows and _Cols are Dynamic.
    + *
    + * + * ABI and storage layout + * + * The table below summarizes the ABI of some possible Matrix instances which is fixed thorough the lifetime of Eigen 3. + * + * + * + * + * + * + *
    Matrix typeEquivalent C structure
    \code Matrix \endcode\code + * struct { + * T *data; // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0 + * Eigen::Index rows, cols; + * }; + * \endcode
    \code + * Matrix + * Matrix \endcode\code + * struct { + * T *data; // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0 + * Eigen::Index size; + * }; + * \endcode
    \code Matrix \endcode\code + * struct { + * T data[Rows*Cols]; // with (size_t(data)%A(Rows*Cols*sizeof(T)))==0 + * }; + * \endcode
    \code Matrix \endcode\code + * struct { + * T data[MaxRows*MaxCols]; // with (size_t(data)%A(MaxRows*MaxCols*sizeof(T)))==0 + * Eigen::Index rows, cols; + * }; + * \endcode
    + * Note that in this table Rows, Cols, MaxRows and MaxCols are all positive integers. A(S) is defined to the largest possible power-of-two + * smaller to EIGEN_MAX_STATIC_ALIGN_BYTES. + * + * \see MatrixBase for the majority of the API methods for matrices, \ref TopicClassHierarchy, + * \ref TopicStorageOrders + */ + +template +class Matrix + : public PlainObjectBase > +{ + public: + + /** \brief Base class typedef. + * \sa PlainObjectBase + */ + typedef PlainObjectBase Base; + + enum { Options = _Options }; + + EIGEN_DENSE_PUBLIC_INTERFACE(Matrix) + + typedef typename Base::PlainObject PlainObject; + + using Base::base; + using Base::coeffRef; + + /** + * \brief Assigns matrices to each other. + * + * \note This is a special case of the templated operator=. Its purpose is + * to prevent a default operator= from hiding the templated operator=. + * + * \callgraph + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix& operator=(const Matrix& other) + { + return Base::_set(other); + } + + /** \internal + * \brief Copies the value of the expression \a other into \c *this with automatic resizing. + * + * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized), + * it will be initialized. + * + * Note that copying a row-vector into a vector (and conversely) is allowed. + * The resizing, if any, is then done in the appropriate way so that row-vectors + * remain row-vectors and vectors remain vectors. + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix& operator=(const DenseBase& other) + { + return Base::_set(other); + } + + /* Here, doxygen failed to copy the brief information when using \copydoc */ + + /** + * \brief Copies the generic expression \a other into *this. + * \copydetails DenseBase::operator=(const EigenBase &other) + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix& operator=(const EigenBase &other) + { + return Base::operator=(other); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix& operator=(const ReturnByValue& func) + { + return Base::operator=(func); + } + + /** \brief Default constructor. + * + * For fixed-size matrices, does nothing. + * + * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix + * is called a null matrix. This constructor is the unique way to create null matrices: resizing + * a matrix to 0 is not supported. + * + * \sa resize(Index,Index) + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix() : Base() + { + Base::_check_template_params(); + EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + } + + // FIXME is it still needed + EIGEN_DEVICE_FUNC + explicit Matrix(internal::constructor_without_unaligned_array_assert) + : Base(internal::constructor_without_unaligned_array_assert()) + { Base::_check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED } + +#if EIGEN_HAS_RVALUE_REFERENCES + EIGEN_DEVICE_FUNC + Matrix(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible::value) + : Base(std::move(other)) + { + Base::_check_template_params(); + if (RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic) + Base::_set_noalias(other); + } + EIGEN_DEVICE_FUNC + Matrix& operator=(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable::value) + { + other.swap(*this); + return *this; + } +#endif + + #ifndef EIGEN_PARSED_BY_DOXYGEN + + // This constructor is for both 1x1 matrices and dynamic vectors + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE explicit Matrix(const T& x) + { + Base::_check_template_params(); + Base::template _init1(x); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y) + { + Base::_check_template_params(); + Base::template _init2(x, y); + } + #else + /** \brief Constructs a fixed-sized matrix initialized with coefficients starting at \a data */ + EIGEN_DEVICE_FUNC + explicit Matrix(const Scalar *data); + + /** \brief Constructs a vector or row-vector with given dimension. \only_for_vectors + * + * This is useful for dynamic-size vectors. For fixed-size vectors, + * it is redundant to pass these parameters, so one should use the default constructor + * Matrix() instead. + * + * \warning This constructor is disabled for fixed-size \c 1x1 matrices. For instance, + * calling Matrix(1) will call the initialization constructor: Matrix(const Scalar&). + * For fixed-size \c 1x1 matrices it is therefore recommended to use the default + * constructor Matrix() instead, especially when using one of the non standard + * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives). + */ + EIGEN_STRONG_INLINE explicit Matrix(Index dim); + /** \brief Constructs an initialized 1x1 matrix with the given coefficient */ + Matrix(const Scalar& x); + /** \brief Constructs an uninitialized matrix with \a rows rows and \a cols columns. + * + * This is useful for dynamic-size matrices. For fixed-size matrices, + * it is redundant to pass these parameters, so one should use the default constructor + * Matrix() instead. + * + * \warning This constructor is disabled for fixed-size \c 1x2 and \c 2x1 vectors. For instance, + * calling Matrix2f(2,1) will call the initialization constructor: Matrix(const Scalar& x, const Scalar& y). + * For fixed-size \c 1x2 or \c 2x1 vectors it is therefore recommended to use the default + * constructor Matrix() instead, especially when using one of the non standard + * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives). + */ + EIGEN_DEVICE_FUNC + Matrix(Index rows, Index cols); + + /** \brief Constructs an initialized 2D vector with given coefficients */ + Matrix(const Scalar& x, const Scalar& y); + #endif + + /** \brief Constructs an initialized 3D vector with given coefficients */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z) + { + Base::_check_template_params(); + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 3) + m_storage.data()[0] = x; + m_storage.data()[1] = y; + m_storage.data()[2] = z; + } + /** \brief Constructs an initialized 4D vector with given coefficients */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w) + { + Base::_check_template_params(); + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 4) + m_storage.data()[0] = x; + m_storage.data()[1] = y; + m_storage.data()[2] = z; + m_storage.data()[3] = w; + } + + + /** \brief Copy constructor */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix(const Matrix& other) : Base(other) + { } + + /** \brief Copy constructor for generic expressions. + * \sa MatrixBase::operator=(const EigenBase&) + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Matrix(const EigenBase &other) + : Base(other.derived()) + { } + + EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; } + EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); } + + /////////// Geometry module /////////// + + template + EIGEN_DEVICE_FUNC + explicit Matrix(const RotationBase& r); + template + EIGEN_DEVICE_FUNC + Matrix& operator=(const RotationBase& r); + + // allow to extend Matrix outside Eigen + #ifdef EIGEN_MATRIX_PLUGIN + #include EIGEN_MATRIX_PLUGIN + #endif + + protected: + template + friend struct internal::conservative_resize_like_impl; + + using Base::m_storage; +}; + +/** \defgroup matrixtypedefs Global matrix typedefs + * + * \ingroup Core_Module + * + * Eigen defines several typedef shortcuts for most common matrix and vector types. + * + * The general patterns are the following: + * + * \c MatrixSizeType where \c Size can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size, + * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd + * for complex double. + * + * For example, \c Matrix3d is a fixed-size 3x3 matrix type of doubles, and \c MatrixXf is a dynamic-size matrix of floats. + * + * There are also \c VectorSizeType and \c RowVectorSizeType which are self-explanatory. For example, \c Vector4cf is + * a fixed-size vector of 4 complex floats. + * + * \sa class Matrix + */ + +#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \ +/** \ingroup matrixtypedefs */ \ +typedef Matrix Matrix##SizeSuffix##TypeSuffix; \ +/** \ingroup matrixtypedefs */ \ +typedef Matrix Vector##SizeSuffix##TypeSuffix; \ +/** \ingroup matrixtypedefs */ \ +typedef Matrix RowVector##SizeSuffix##TypeSuffix; + +#define EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \ +/** \ingroup matrixtypedefs */ \ +typedef Matrix Matrix##Size##X##TypeSuffix; \ +/** \ingroup matrixtypedefs */ \ +typedef Matrix Matrix##X##Size##TypeSuffix; + +#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \ +EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \ +EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \ +EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \ +EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \ +EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \ +EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \ +EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 4) + +EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int, i) +EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float, f) +EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double, d) +EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex, cf) +EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex, cd) + +#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES +#undef EIGEN_MAKE_TYPEDEFS +#undef EIGEN_MAKE_FIXED_TYPEDEFS + +} // end namespace Eigen + +#endif // EIGEN_MATRIX_H diff --git a/3rdparty/eigen3/Eigen/src/Core/MatrixBase.h b/3rdparty/eigen3/Eigen/src/Core/MatrixBase.h new file mode 100644 index 0000000..05db488 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/MatrixBase.h @@ -0,0 +1,521 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2009 Benoit Jacob +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_MATRIXBASE_H +#define EIGEN_MATRIXBASE_H + +namespace Eigen { + +/** \class MatrixBase + * \ingroup Core_Module + * + * \brief Base class for all dense matrices, vectors, and expressions + * + * This class is the base that is inherited by all matrix, vector, and related expression + * types. Most of the Eigen API is contained in this class, and its base classes. Other important + * classes for the Eigen API are Matrix, and VectorwiseOp. + * + * Note that some methods are defined in other modules such as the \ref LU_Module LU module + * for all functions related to matrix inversions. + * + * \tparam Derived is the derived type, e.g. a matrix type, or an expression, etc. + * + * When writing a function taking Eigen objects as argument, if you want your function + * to take as argument any matrix, vector, or expression, just let it take a + * MatrixBase argument. As an example, here is a function printFirstRow which, given + * a matrix, vector, or expression \a x, prints the first row of \a x. + * + * \code + template + void printFirstRow(const Eigen::MatrixBase& x) + { + cout << x.row(0) << endl; + } + * \endcode + * + * This class can be extended with the help of the plugin mechanism described on the page + * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIXBASE_PLUGIN. + * + * \sa \blank \ref TopicClassHierarchy + */ +template class MatrixBase + : public DenseBase +{ + public: +#ifndef EIGEN_PARSED_BY_DOXYGEN + typedef MatrixBase StorageBaseType; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::StorageIndex StorageIndex; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; + typedef typename NumTraits::Real RealScalar; + + typedef DenseBase Base; + using Base::RowsAtCompileTime; + using Base::ColsAtCompileTime; + using Base::SizeAtCompileTime; + using Base::MaxRowsAtCompileTime; + using Base::MaxColsAtCompileTime; + using Base::MaxSizeAtCompileTime; + using Base::IsVectorAtCompileTime; + using Base::Flags; + + using Base::derived; + using Base::const_cast_derived; + using Base::rows; + using Base::cols; + using Base::size; + using Base::coeff; + using Base::coeffRef; + using Base::lazyAssign; + using Base::eval; + using Base::operator+=; + using Base::operator-=; + using Base::operator*=; + using Base::operator/=; + + typedef typename Base::CoeffReturnType CoeffReturnType; + typedef typename Base::ConstTransposeReturnType ConstTransposeReturnType; + typedef typename Base::RowXpr RowXpr; + typedef typename Base::ColXpr ColXpr; +#endif // not EIGEN_PARSED_BY_DOXYGEN + + + +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** type of the equivalent square matrix */ + typedef Matrix SquareMatrixType; +#endif // not EIGEN_PARSED_BY_DOXYGEN + + /** \returns the size of the main diagonal, which is min(rows(),cols()). + * \sa rows(), cols(), SizeAtCompileTime. */ + EIGEN_DEVICE_FUNC + inline Index diagonalSize() const { return (numext::mini)(rows(),cols()); } + + typedef typename Base::PlainObject PlainObject; + +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** \internal Represents a matrix with all coefficients equal to one another*/ + typedef CwiseNullaryOp,PlainObject> ConstantReturnType; + /** \internal the return type of MatrixBase::adjoint() */ + typedef typename internal::conditional::IsComplex, + CwiseUnaryOp, ConstTransposeReturnType>, + ConstTransposeReturnType + >::type AdjointReturnType; + /** \internal Return type of eigenvalues() */ + typedef Matrix, internal::traits::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType; + /** \internal the return type of identity */ + typedef CwiseNullaryOp,PlainObject> IdentityReturnType; + /** \internal the return type of unit vectors */ + typedef Block, SquareMatrixType>, + internal::traits::RowsAtCompileTime, + internal::traits::ColsAtCompileTime> BasisReturnType; +#endif // not EIGEN_PARSED_BY_DOXYGEN + +#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase +#define EIGEN_DOC_UNARY_ADDONS(X,Y) +# include "../plugins/CommonCwiseUnaryOps.h" +# include "../plugins/CommonCwiseBinaryOps.h" +# include "../plugins/MatrixCwiseUnaryOps.h" +# include "../plugins/MatrixCwiseBinaryOps.h" +# ifdef EIGEN_MATRIXBASE_PLUGIN +# include EIGEN_MATRIXBASE_PLUGIN +# endif +#undef EIGEN_CURRENT_STORAGE_BASE_CLASS +#undef EIGEN_DOC_UNARY_ADDONS + + /** Special case of the template operator=, in order to prevent the compiler + * from generating a default operator= (issue hit with g++ 4.1) + */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator=(const MatrixBase& other); + + // We cannot inherit here via Base::operator= since it is causing + // trouble with MSVC. + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator=(const DenseBase& other); + + template + EIGEN_DEVICE_FUNC + Derived& operator=(const EigenBase& other); + + template + EIGEN_DEVICE_FUNC + Derived& operator=(const ReturnByValue& other); + + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator+=(const MatrixBase& other); + template + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + Derived& operator-=(const MatrixBase& other); + + template + EIGEN_DEVICE_FUNC + const Product + operator*(const MatrixBase &other) const; + + template + EIGEN_DEVICE_FUNC + const Product + lazyProduct(const MatrixBase &other) const; + + template + Derived& operator*=(const EigenBase& other); + + template + void applyOnTheLeft(const EigenBase& other); + + template + void applyOnTheRight(const EigenBase& other); + + template + EIGEN_DEVICE_FUNC + const Product + operator*(const DiagonalBase &diagonal) const; + + template + EIGEN_DEVICE_FUNC + typename ScalarBinaryOpTraits::Scalar,typename internal::traits::Scalar>::ReturnType + dot(const MatrixBase& other) const; + + EIGEN_DEVICE_FUNC RealScalar squaredNorm() const; + EIGEN_DEVICE_FUNC RealScalar norm() const; + RealScalar stableNorm() const; + RealScalar blueNorm() const; + RealScalar hypotNorm() const; + EIGEN_DEVICE_FUNC const PlainObject normalized() const; + EIGEN_DEVICE_FUNC const PlainObject stableNormalized() const; + EIGEN_DEVICE_FUNC void normalize(); + EIGEN_DEVICE_FUNC void stableNormalize(); + + EIGEN_DEVICE_FUNC const AdjointReturnType adjoint() const; + EIGEN_DEVICE_FUNC void adjointInPlace(); + + typedef Diagonal DiagonalReturnType; + EIGEN_DEVICE_FUNC + DiagonalReturnType diagonal(); + + typedef typename internal::add_const >::type ConstDiagonalReturnType; + EIGEN_DEVICE_FUNC + ConstDiagonalReturnType diagonal() const; + + template struct DiagonalIndexReturnType { typedef Diagonal Type; }; + template struct ConstDiagonalIndexReturnType { typedef const Diagonal Type; }; + + template + EIGEN_DEVICE_FUNC + typename DiagonalIndexReturnType::Type diagonal(); + + template + EIGEN_DEVICE_FUNC + typename ConstDiagonalIndexReturnType::Type diagonal() const; + + typedef Diagonal DiagonalDynamicIndexReturnType; + typedef typename internal::add_const >::type ConstDiagonalDynamicIndexReturnType; + + EIGEN_DEVICE_FUNC + DiagonalDynamicIndexReturnType diagonal(Index index); + EIGEN_DEVICE_FUNC + ConstDiagonalDynamicIndexReturnType diagonal(Index index) const; + + template struct TriangularViewReturnType { typedef TriangularView Type; }; + template struct ConstTriangularViewReturnType { typedef const TriangularView Type; }; + + template + EIGEN_DEVICE_FUNC + typename TriangularViewReturnType::Type triangularView(); + template + EIGEN_DEVICE_FUNC + typename ConstTriangularViewReturnType::Type triangularView() const; + + template struct SelfAdjointViewReturnType { typedef SelfAdjointView Type; }; + template struct ConstSelfAdjointViewReturnType { typedef const SelfAdjointView Type; }; + + template + EIGEN_DEVICE_FUNC + typename SelfAdjointViewReturnType::Type selfadjointView(); + template + EIGEN_DEVICE_FUNC + typename ConstSelfAdjointViewReturnType::Type selfadjointView() const; + + const SparseView sparseView(const Scalar& m_reference = Scalar(0), + const typename NumTraits::Real& m_epsilon = NumTraits::dummy_precision()) const; + EIGEN_DEVICE_FUNC static const IdentityReturnType Identity(); + EIGEN_DEVICE_FUNC static const IdentityReturnType Identity(Index rows, Index cols); + EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index size, Index i); + EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index i); + EIGEN_DEVICE_FUNC static const BasisReturnType UnitX(); + EIGEN_DEVICE_FUNC static const BasisReturnType UnitY(); + EIGEN_DEVICE_FUNC static const BasisReturnType UnitZ(); + EIGEN_DEVICE_FUNC static const BasisReturnType UnitW(); + + EIGEN_DEVICE_FUNC + const DiagonalWrapper asDiagonal() const; + const PermutationWrapper asPermutation() const; + + EIGEN_DEVICE_FUNC + Derived& setIdentity(); + EIGEN_DEVICE_FUNC + Derived& setIdentity(Index rows, Index cols); + + bool isIdentity(const RealScalar& prec = NumTraits::dummy_precision()) const; + bool isDiagonal(const RealScalar& prec = NumTraits::dummy_precision()) const; + + bool isUpperTriangular(const RealScalar& prec = NumTraits::dummy_precision()) const; + bool isLowerTriangular(const RealScalar& prec = NumTraits::dummy_precision()) const; + + template + bool isOrthogonal(const MatrixBase& other, + const RealScalar& prec = NumTraits::dummy_precision()) const; + bool isUnitary(const RealScalar& prec = NumTraits::dummy_precision()) const; + + /** \returns true if each coefficients of \c *this and \a other are all exactly equal. + * \warning When using floating point scalar values you probably should rather use a + * fuzzy comparison such as isApprox() + * \sa isApprox(), operator!= */ + template + EIGEN_DEVICE_FUNC inline bool operator==(const MatrixBase& other) const + { return cwiseEqual(other).all(); } + + /** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other. + * \warning When using floating point scalar values you probably should rather use a + * fuzzy comparison such as isApprox() + * \sa isApprox(), operator== */ + template + EIGEN_DEVICE_FUNC inline bool operator!=(const MatrixBase& other) const + { return cwiseNotEqual(other).any(); } + + NoAlias noalias(); + + // TODO forceAlignedAccess is temporarily disabled + // Need to find a nicer workaround. + inline const Derived& forceAlignedAccess() const { return derived(); } + inline Derived& forceAlignedAccess() { return derived(); } + template inline const Derived& forceAlignedAccessIf() const { return derived(); } + template inline Derived& forceAlignedAccessIf() { return derived(); } + + EIGEN_DEVICE_FUNC Scalar trace() const; + + template EIGEN_DEVICE_FUNC RealScalar lpNorm() const; + + EIGEN_DEVICE_FUNC MatrixBase& matrix() { return *this; } + EIGEN_DEVICE_FUNC const MatrixBase& matrix() const { return *this; } + + /** \returns an \link Eigen::ArrayBase Array \endlink expression of this matrix + * \sa ArrayBase::matrix() */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper array() { return ArrayWrapper(derived()); } + /** \returns a const \link Eigen::ArrayBase Array \endlink expression of this matrix + * \sa ArrayBase::matrix() */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper array() const { return ArrayWrapper(derived()); } + +/////////// LU module /////////// + + inline const FullPivLU fullPivLu() const; + inline const PartialPivLU partialPivLu() const; + + inline const PartialPivLU lu() const; + + inline const Inverse inverse() const; + + template + inline void computeInverseAndDetWithCheck( + ResultType& inverse, + typename ResultType::Scalar& determinant, + bool& invertible, + const RealScalar& absDeterminantThreshold = NumTraits::dummy_precision() + ) const; + template + inline void computeInverseWithCheck( + ResultType& inverse, + bool& invertible, + const RealScalar& absDeterminantThreshold = NumTraits::dummy_precision() + ) const; + Scalar determinant() const; + +/////////// Cholesky module /////////// + + inline const LLT llt() const; + inline const LDLT ldlt() const; + +/////////// QR module /////////// + + inline const HouseholderQR householderQr() const; + inline const ColPivHouseholderQR colPivHouseholderQr() const; + inline const FullPivHouseholderQR fullPivHouseholderQr() const; + inline const CompleteOrthogonalDecomposition completeOrthogonalDecomposition() const; + +/////////// Eigenvalues module /////////// + + inline EigenvaluesReturnType eigenvalues() const; + inline RealScalar operatorNorm() const; + +/////////// SVD module /////////// + + inline JacobiSVD jacobiSvd(unsigned int computationOptions = 0) const; + inline BDCSVD bdcSvd(unsigned int computationOptions = 0) const; + +/////////// Geometry module /////////// + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /// \internal helper struct to form the return type of the cross product + template struct cross_product_return_type { + typedef typename ScalarBinaryOpTraits::Scalar,typename internal::traits::Scalar>::ReturnType Scalar; + typedef Matrix type; + }; + #endif // EIGEN_PARSED_BY_DOXYGEN + template + EIGEN_DEVICE_FUNC +#ifndef EIGEN_PARSED_BY_DOXYGEN + inline typename cross_product_return_type::type +#else + inline PlainObject +#endif + cross(const MatrixBase& other) const; + + template + EIGEN_DEVICE_FUNC + inline PlainObject cross3(const MatrixBase& other) const; + + EIGEN_DEVICE_FUNC + inline PlainObject unitOrthogonal(void) const; + + EIGEN_DEVICE_FUNC + inline Matrix eulerAngles(Index a0, Index a1, Index a2) const; + + // put this as separate enum value to work around possible GCC 4.3 bug (?) + enum { HomogeneousReturnTypeDirection = ColsAtCompileTime==1&&RowsAtCompileTime==1 ? ((internal::traits::Flags&RowMajorBit)==RowMajorBit ? Horizontal : Vertical) + : ColsAtCompileTime==1 ? Vertical : Horizontal }; + typedef Homogeneous HomogeneousReturnType; + EIGEN_DEVICE_FUNC + inline HomogeneousReturnType homogeneous() const; + + enum { + SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1 + }; + typedef Block::ColsAtCompileTime==1 ? SizeMinusOne : 1, + internal::traits::ColsAtCompileTime==1 ? 1 : SizeMinusOne> ConstStartMinusOne; + typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(ConstStartMinusOne,Scalar,quotient) HNormalizedReturnType; + EIGEN_DEVICE_FUNC + inline const HNormalizedReturnType hnormalized() const; + +////////// Householder module /////////// + + void makeHouseholderInPlace(Scalar& tau, RealScalar& beta); + template + void makeHouseholder(EssentialPart& essential, + Scalar& tau, RealScalar& beta) const; + template + void applyHouseholderOnTheLeft(const EssentialPart& essential, + const Scalar& tau, + Scalar* workspace); + template + void applyHouseholderOnTheRight(const EssentialPart& essential, + const Scalar& tau, + Scalar* workspace); + +///////// Jacobi module ///////// + + template + void applyOnTheLeft(Index p, Index q, const JacobiRotation& j); + template + void applyOnTheRight(Index p, Index q, const JacobiRotation& j); + +///////// SparseCore module ///////// + + template + EIGEN_STRONG_INLINE const typename SparseMatrixBase::template CwiseProductDenseReturnType::Type + cwiseProduct(const SparseMatrixBase &other) const + { + return other.cwiseProduct(derived()); + } + +///////// MatrixFunctions module ///////// + + typedef typename internal::stem_function::type StemFunction; + const MatrixExponentialReturnValue exp() const; + const MatrixFunctionReturnValue matrixFunction(StemFunction f) const; + const MatrixFunctionReturnValue cosh() const; + const MatrixFunctionReturnValue sinh() const; + const MatrixFunctionReturnValue cos() const; + const MatrixFunctionReturnValue sin() const; + const MatrixSquareRootReturnValue sqrt() const; + const MatrixLogarithmReturnValue log() const; + const MatrixPowerReturnValue pow(const RealScalar& p) const; + const MatrixComplexPowerReturnValue pow(const std::complex& p) const; + + protected: + EIGEN_DEVICE_FUNC MatrixBase() : Base() {} + + private: + EIGEN_DEVICE_FUNC explicit MatrixBase(int); + EIGEN_DEVICE_FUNC MatrixBase(int,int); + template EIGEN_DEVICE_FUNC explicit MatrixBase(const MatrixBase&); + protected: + // mixing arrays and matrices is not legal + template Derived& operator+=(const ArrayBase& ) + {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;} + // mixing arrays and matrices is not legal + template Derived& operator-=(const ArrayBase& ) + {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;} +}; + + +/*************************************************************************** +* Implementation of matrix base methods +***************************************************************************/ + +/** replaces \c *this by \c *this * \a other. + * + * \returns a reference to \c *this + * + * Example: \include MatrixBase_applyOnTheRight.cpp + * Output: \verbinclude MatrixBase_applyOnTheRight.out + */ +template +template +inline Derived& +MatrixBase::operator*=(const EigenBase &other) +{ + other.derived().applyThisOnTheRight(derived()); + return derived(); +} + +/** replaces \c *this by \c *this * \a other. It is equivalent to MatrixBase::operator*=(). + * + * Example: \include MatrixBase_applyOnTheRight.cpp + * Output: \verbinclude MatrixBase_applyOnTheRight.out + */ +template +template +inline void MatrixBase::applyOnTheRight(const EigenBase &other) +{ + other.derived().applyThisOnTheRight(derived()); +} + +/** replaces \c *this by \a other * \c *this. + * + * Example: \include MatrixBase_applyOnTheLeft.cpp + * Output: \verbinclude MatrixBase_applyOnTheLeft.out + */ +template +template +inline void MatrixBase::applyOnTheLeft(const EigenBase &other) +{ + other.derived().applyThisOnTheLeft(derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_MATRIXBASE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/NestByValue.h b/3rdparty/eigen3/Eigen/src/Core/NestByValue.h new file mode 100644 index 0000000..13adf07 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/NestByValue.h @@ -0,0 +1,110 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_NESTBYVALUE_H +#define EIGEN_NESTBYVALUE_H + +namespace Eigen { + +namespace internal { +template +struct traits > : public traits +{}; +} + +/** \class NestByValue + * \ingroup Core_Module + * + * \brief Expression which must be nested by value + * + * \tparam ExpressionType the type of the object of which we are requiring nesting-by-value + * + * This class is the return type of MatrixBase::nestByValue() + * and most of the time this is the only way it is used. + * + * \sa MatrixBase::nestByValue() + */ +template class NestByValue + : public internal::dense_xpr_base< NestByValue >::type +{ + public: + + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue) + + EIGEN_DEVICE_FUNC explicit inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {} + + EIGEN_DEVICE_FUNC inline Index rows() const { return m_expression.rows(); } + EIGEN_DEVICE_FUNC inline Index cols() const { return m_expression.cols(); } + EIGEN_DEVICE_FUNC inline Index outerStride() const { return m_expression.outerStride(); } + EIGEN_DEVICE_FUNC inline Index innerStride() const { return m_expression.innerStride(); } + + EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const + { + return m_expression.coeff(row, col); + } + + EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) + { + return m_expression.const_cast_derived().coeffRef(row, col); + } + + EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const + { + return m_expression.coeff(index); + } + + EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index) + { + return m_expression.const_cast_derived().coeffRef(index); + } + + template + inline const PacketScalar packet(Index row, Index col) const + { + return m_expression.template packet(row, col); + } + + template + inline void writePacket(Index row, Index col, const PacketScalar& x) + { + m_expression.const_cast_derived().template writePacket(row, col, x); + } + + template + inline const PacketScalar packet(Index index) const + { + return m_expression.template packet(index); + } + + template + inline void writePacket(Index index, const PacketScalar& x) + { + m_expression.const_cast_derived().template writePacket(index, x); + } + + EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; } + + protected: + const ExpressionType m_expression; +}; + +/** \returns an expression of the temporary version of *this. + */ +template +inline const NestByValue +DenseBase::nestByValue() const +{ + return NestByValue(derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_NESTBYVALUE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/NoAlias.h b/3rdparty/eigen3/Eigen/src/Core/NoAlias.h new file mode 100644 index 0000000..3390801 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/NoAlias.h @@ -0,0 +1,108 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_NOALIAS_H +#define EIGEN_NOALIAS_H + +namespace Eigen { + +/** \class NoAlias + * \ingroup Core_Module + * + * \brief Pseudo expression providing an operator = assuming no aliasing + * + * \tparam ExpressionType the type of the object on which to do the lazy assignment + * + * This class represents an expression with special assignment operators + * assuming no aliasing between the target expression and the source expression. + * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression. + * It is the return type of MatrixBase::noalias() + * and most of the time this is the only way it is used. + * + * \sa MatrixBase::noalias() + */ +template class StorageBase> +class NoAlias +{ + public: + typedef typename ExpressionType::Scalar Scalar; + + explicit NoAlias(ExpressionType& expression) : m_expression(expression) {} + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase& other) + { + call_assignment_no_alias(m_expression, other.derived(), internal::assign_op()); + return m_expression; + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase& other) + { + call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op()); + return m_expression; + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase& other) + { + call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op()); + return m_expression; + } + + EIGEN_DEVICE_FUNC + ExpressionType& expression() const + { + return m_expression; + } + + protected: + ExpressionType& m_expression; +}; + +/** \returns a pseudo expression of \c *this with an operator= assuming + * no aliasing between \c *this and the source expression. + * + * More precisely, noalias() allows to bypass the EvalBeforeAssignBit flag. + * Currently, even though several expressions may alias, only product + * expressions have this flag. Therefore, noalias() is only usefull when + * the source expression contains a matrix product. + * + * Here are some examples where noalias is usefull: + * \code + * D.noalias() = A * B; + * D.noalias() += A.transpose() * B; + * D.noalias() -= 2 * A * B.adjoint(); + * \endcode + * + * On the other hand the following example will lead to a \b wrong result: + * \code + * A.noalias() = A * B; + * \endcode + * because the result matrix A is also an operand of the matrix product. Therefore, + * there is no alternative than evaluating A * B in a temporary, that is the default + * behavior when you write: + * \code + * A = A * B; + * \endcode + * + * \sa class NoAlias + */ +template +NoAlias MatrixBase::noalias() +{ + return NoAlias(derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_NOALIAS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/NumTraits.h b/3rdparty/eigen3/Eigen/src/Core/NumTraits.h new file mode 100644 index 0000000..daf4898 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/NumTraits.h @@ -0,0 +1,248 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2010 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_NUMTRAITS_H +#define EIGEN_NUMTRAITS_H + +namespace Eigen { + +namespace internal { + +// default implementation of digits10(), based on numeric_limits if specialized, +// 0 for integer types, and log10(epsilon()) otherwise. +template< typename T, + bool use_numeric_limits = std::numeric_limits::is_specialized, + bool is_integer = NumTraits::IsInteger> +struct default_digits10_impl +{ + static int run() { return std::numeric_limits::digits10; } +}; + +template +struct default_digits10_impl // Floating point +{ + static int run() { + using std::log10; + using std::ceil; + typedef typename NumTraits::Real Real; + return int(ceil(-log10(NumTraits::epsilon()))); + } +}; + +template +struct default_digits10_impl // Integer +{ + static int run() { return 0; } +}; + +} // end namespace internal + +/** \class NumTraits + * \ingroup Core_Module + * + * \brief Holds information about the various numeric (i.e. scalar) types allowed by Eigen. + * + * \tparam T the numeric type at hand + * + * This class stores enums, typedefs and static methods giving information about a numeric type. + * + * The provided data consists of: + * \li A typedef \c Real, giving the "real part" type of \a T. If \a T is already real, + * then \c Real is just a typedef to \a T. If \a T is \c std::complex then \c Real + * is a typedef to \a U. + * \li A typedef \c NonInteger, giving the type that should be used for operations producing non-integral values, + * such as quotients, square roots, etc. If \a T is a floating-point type, then this typedef just gives + * \a T again. Note however that many Eigen functions such as internal::sqrt simply refuse to + * take integers. Outside of a few cases, Eigen doesn't do automatic type promotion. Thus, this typedef is + * only intended as a helper for code that needs to explicitly promote types. + * \li A typedef \c Literal giving the type to use for numeric literals such as "2" or "0.5". For instance, for \c std::complex, Literal is defined as \c U. + * Of course, this type must be fully compatible with \a T. In doubt, just use \a T here. + * \li A typedef \a Nested giving the type to use to nest a value inside of the expression tree. If you don't know what + * this means, just use \a T here. + * \li An enum value \a IsComplex. It is equal to 1 if \a T is a \c std::complex + * type, and to 0 otherwise. + * \li An enum value \a IsInteger. It is equal to \c 1 if \a T is an integer type such as \c int, + * and to \c 0 otherwise. + * \li Enum values ReadCost, AddCost and MulCost representing a rough estimate of the number of CPU cycles needed + * to by move / add / mul instructions respectively, assuming the data is already stored in CPU registers. + * Stay vague here. No need to do architecture-specific stuff. + * \li An enum value \a IsSigned. It is equal to \c 1 if \a T is a signed type and to 0 if \a T is unsigned. + * \li An enum value \a RequireInitialization. It is equal to \c 1 if the constructor of the numeric type \a T must + * be called, and to 0 if it is safe not to call it. Default is 0 if \a T is an arithmetic type, and 1 otherwise. + * \li An epsilon() function which, unlike std::numeric_limits::epsilon(), + * it returns a \a Real instead of a \a T. + * \li A dummy_precision() function returning a weak epsilon value. It is mainly used as a default + * value by the fuzzy comparison operators. + * \li highest() and lowest() functions returning the highest and lowest possible values respectively. + * \li digits10() function returning the number of decimal digits that can be represented without change. This is + * the analogue of std::numeric_limits::digits10 + * which is used as the default implementation if specialized. + */ + +template struct GenericNumTraits +{ + enum { + IsInteger = std::numeric_limits::is_integer, + IsSigned = std::numeric_limits::is_signed, + IsComplex = 0, + RequireInitialization = internal::is_arithmetic::value ? 0 : 1, + ReadCost = 1, + AddCost = 1, + MulCost = 1 + }; + + typedef T Real; + typedef typename internal::conditional< + IsInteger, + typename internal::conditional::type, + T + >::type NonInteger; + typedef T Nested; + typedef T Literal; + + EIGEN_DEVICE_FUNC + static inline Real epsilon() + { + return numext::numeric_limits::epsilon(); + } + + EIGEN_DEVICE_FUNC + static inline int digits10() + { + return internal::default_digits10_impl::run(); + } + + EIGEN_DEVICE_FUNC + static inline Real dummy_precision() + { + // make sure to override this for floating-point types + return Real(0); + } + + + EIGEN_DEVICE_FUNC + static inline T highest() { + return (numext::numeric_limits::max)(); + } + + EIGEN_DEVICE_FUNC + static inline T lowest() { + return IsInteger ? (numext::numeric_limits::min)() : (-(numext::numeric_limits::max)()); + } + + EIGEN_DEVICE_FUNC + static inline T infinity() { + return numext::numeric_limits::infinity(); + } + + EIGEN_DEVICE_FUNC + static inline T quiet_NaN() { + return numext::numeric_limits::quiet_NaN(); + } +}; + +template struct NumTraits : GenericNumTraits +{}; + +template<> struct NumTraits + : GenericNumTraits +{ + EIGEN_DEVICE_FUNC + static inline float dummy_precision() { return 1e-5f; } +}; + +template<> struct NumTraits : GenericNumTraits +{ + EIGEN_DEVICE_FUNC + static inline double dummy_precision() { return 1e-12; } +}; + +template<> struct NumTraits + : GenericNumTraits +{ + static inline long double dummy_precision() { return 1e-15l; } +}; + +template struct NumTraits > + : GenericNumTraits > +{ + typedef _Real Real; + typedef typename NumTraits<_Real>::Literal Literal; + enum { + IsComplex = 1, + RequireInitialization = NumTraits<_Real>::RequireInitialization, + ReadCost = 2 * NumTraits<_Real>::ReadCost, + AddCost = 2 * NumTraits::AddCost, + MulCost = 4 * NumTraits::MulCost + 2 * NumTraits::AddCost + }; + + EIGEN_DEVICE_FUNC + static inline Real epsilon() { return NumTraits::epsilon(); } + EIGEN_DEVICE_FUNC + static inline Real dummy_precision() { return NumTraits::dummy_precision(); } + EIGEN_DEVICE_FUNC + static inline int digits10() { return NumTraits::digits10(); } +}; + +template +struct NumTraits > +{ + typedef Array ArrayType; + typedef typename NumTraits::Real RealScalar; + typedef Array Real; + typedef typename NumTraits::NonInteger NonIntegerScalar; + typedef Array NonInteger; + typedef ArrayType & Nested; + typedef typename NumTraits::Literal Literal; + + enum { + IsComplex = NumTraits::IsComplex, + IsInteger = NumTraits::IsInteger, + IsSigned = NumTraits::IsSigned, + RequireInitialization = 1, + ReadCost = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * NumTraits::ReadCost, + AddCost = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * NumTraits::AddCost, + MulCost = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * NumTraits::MulCost + }; + + EIGEN_DEVICE_FUNC + static inline RealScalar epsilon() { return NumTraits::epsilon(); } + EIGEN_DEVICE_FUNC + static inline RealScalar dummy_precision() { return NumTraits::dummy_precision(); } + + static inline int digits10() { return NumTraits::digits10(); } +}; + +template<> struct NumTraits + : GenericNumTraits +{ + enum { + RequireInitialization = 1, + ReadCost = HugeCost, + AddCost = HugeCost, + MulCost = HugeCost + }; + + static inline int digits10() { return 0; } + +private: + static inline std::string epsilon(); + static inline std::string dummy_precision(); + static inline std::string lowest(); + static inline std::string highest(); + static inline std::string infinity(); + static inline std::string quiet_NaN(); +}; + +// Empty specialization for void to allow template specialization based on NumTraits::Real with T==void and SFINAE. +template<> struct NumTraits {}; + +} // end namespace Eigen + +#endif // EIGEN_NUMTRAITS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/PermutationMatrix.h b/3rdparty/eigen3/Eigen/src/Core/PermutationMatrix.h new file mode 100644 index 0000000..b1fb455 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/PermutationMatrix.h @@ -0,0 +1,633 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Benoit Jacob +// Copyright (C) 2009-2015 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_PERMUTATIONMATRIX_H +#define EIGEN_PERMUTATIONMATRIX_H + +namespace Eigen { + +namespace internal { + +enum PermPermProduct_t {PermPermProduct}; + +} // end namespace internal + +/** \class PermutationBase + * \ingroup Core_Module + * + * \brief Base class for permutations + * + * \tparam Derived the derived class + * + * This class is the base class for all expressions representing a permutation matrix, + * internally stored as a vector of integers. + * The convention followed here is that if \f$ \sigma \f$ is a permutation, the corresponding permutation matrix + * \f$ P_\sigma \f$ is such that if \f$ (e_1,\ldots,e_p) \f$ is the canonical basis, we have: + * \f[ P_\sigma(e_i) = e_{\sigma(i)}. \f] + * This convention ensures that for any two permutations \f$ \sigma, \tau \f$, we have: + * \f[ P_{\sigma\circ\tau} = P_\sigma P_\tau. \f] + * + * Permutation matrices are square and invertible. + * + * Notice that in addition to the member functions and operators listed here, there also are non-member + * operator* to multiply any kind of permutation object with any kind of matrix expression (MatrixBase) + * on either side. + * + * \sa class PermutationMatrix, class PermutationWrapper + */ +template +class PermutationBase : public EigenBase +{ + typedef internal::traits Traits; + typedef EigenBase Base; + public: + + #ifndef EIGEN_PARSED_BY_DOXYGEN + typedef typename Traits::IndicesType IndicesType; + enum { + Flags = Traits::Flags, + RowsAtCompileTime = Traits::RowsAtCompileTime, + ColsAtCompileTime = Traits::ColsAtCompileTime, + MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = Traits::MaxColsAtCompileTime + }; + typedef typename Traits::StorageIndex StorageIndex; + typedef Matrix + DenseMatrixType; + typedef PermutationMatrix + PlainPermutationType; + typedef PlainPermutationType PlainObject; + using Base::derived; + typedef Inverse InverseReturnType; + typedef void Scalar; + #endif + + /** Copies the other permutation into *this */ + template + Derived& operator=(const PermutationBase& other) + { + indices() = other.indices(); + return derived(); + } + + /** Assignment from the Transpositions \a tr */ + template + Derived& operator=(const TranspositionsBase& tr) + { + setIdentity(tr.size()); + for(Index k=size()-1; k>=0; --k) + applyTranspositionOnTheRight(k,tr.coeff(k)); + return derived(); + } + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** This is a special case of the templated operator=. Its purpose is to + * prevent a default operator= from hiding the templated operator=. + */ + Derived& operator=(const PermutationBase& other) + { + indices() = other.indices(); + return derived(); + } + #endif + + /** \returns the number of rows */ + inline Index rows() const { return Index(indices().size()); } + + /** \returns the number of columns */ + inline Index cols() const { return Index(indices().size()); } + + /** \returns the size of a side of the respective square matrix, i.e., the number of indices */ + inline Index size() const { return Index(indices().size()); } + + #ifndef EIGEN_PARSED_BY_DOXYGEN + template + void evalTo(MatrixBase& other) const + { + other.setZero(); + for (Index i=0; i=0 && j>=0 && i=0 && j>=0 && i + void assignTranspose(const PermutationBase& other) + { + for (Index i=0; i + void assignProduct(const Lhs& lhs, const Rhs& rhs) + { + eigen_assert(lhs.cols() == rhs.rows()); + for (Index i=0; i + inline PlainPermutationType operator*(const PermutationBase& other) const + { return PlainPermutationType(internal::PermPermProduct, derived(), other.derived()); } + + /** \returns the product of a permutation with another inverse permutation. + * + * \note \blank \note_try_to_help_rvo + */ + template + inline PlainPermutationType operator*(const InverseImpl& other) const + { return PlainPermutationType(internal::PermPermProduct, *this, other.eval()); } + + /** \returns the product of an inverse permutation with another permutation. + * + * \note \blank \note_try_to_help_rvo + */ + template friend + inline PlainPermutationType operator*(const InverseImpl& other, const PermutationBase& perm) + { return PlainPermutationType(internal::PermPermProduct, other.eval(), perm); } + + /** \returns the determinant of the permutation matrix, which is either 1 or -1 depending on the parity of the permutation. + * + * This function is O(\c n) procedure allocating a buffer of \c n booleans. + */ + Index determinant() const + { + Index res = 1; + Index n = size(); + Matrix mask(n); + mask.fill(false); + Index r = 0; + while(r < n) + { + // search for the next seed + while(r=n) + break; + // we got one, let's follow it until we are back to the seed + Index k0 = r++; + mask.coeffRef(k0) = true; + for(Index k=indices().coeff(k0); k!=k0; k=indices().coeff(k)) + { + mask.coeffRef(k) = true; + res = -res; + } + } + return res; + } + + protected: + +}; + +namespace internal { +template +struct traits > + : traits > +{ + typedef PermutationStorage StorageKind; + typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType; + typedef _StorageIndex StorageIndex; + typedef void Scalar; +}; +} + +/** \class PermutationMatrix + * \ingroup Core_Module + * + * \brief Permutation matrix + * + * \tparam SizeAtCompileTime the number of rows/cols, or Dynamic + * \tparam MaxSizeAtCompileTime the maximum number of rows/cols, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it. + * \tparam _StorageIndex the integer type of the indices + * + * This class represents a permutation matrix, internally stored as a vector of integers. + * + * \sa class PermutationBase, class PermutationWrapper, class DiagonalMatrix + */ +template +class PermutationMatrix : public PermutationBase > +{ + typedef PermutationBase Base; + typedef internal::traits Traits; + public: + + typedef const PermutationMatrix& Nested; + + #ifndef EIGEN_PARSED_BY_DOXYGEN + typedef typename Traits::IndicesType IndicesType; + typedef typename Traits::StorageIndex StorageIndex; + #endif + + inline PermutationMatrix() + {} + + /** Constructs an uninitialized permutation matrix of given size. + */ + explicit inline PermutationMatrix(Index size) : m_indices(size) + { + eigen_internal_assert(size <= NumTraits::highest()); + } + + /** Copy constructor. */ + template + inline PermutationMatrix(const PermutationBase& other) + : m_indices(other.indices()) {} + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** Standard copy constructor. Defined only to prevent a default copy constructor + * from hiding the other templated constructor */ + inline PermutationMatrix(const PermutationMatrix& other) : m_indices(other.indices()) {} + #endif + + /** Generic constructor from expression of the indices. The indices + * array has the meaning that the permutations sends each integer i to indices[i]. + * + * \warning It is your responsibility to check that the indices array that you passes actually + * describes a permutation, i.e., each value between 0 and n-1 occurs exactly once, where n is the + * array's size. + */ + template + explicit inline PermutationMatrix(const MatrixBase& indices) : m_indices(indices) + {} + + /** Convert the Transpositions \a tr to a permutation matrix */ + template + explicit PermutationMatrix(const TranspositionsBase& tr) + : m_indices(tr.size()) + { + *this = tr; + } + + /** Copies the other permutation into *this */ + template + PermutationMatrix& operator=(const PermutationBase& other) + { + m_indices = other.indices(); + return *this; + } + + /** Assignment from the Transpositions \a tr */ + template + PermutationMatrix& operator=(const TranspositionsBase& tr) + { + return Base::operator=(tr.derived()); + } + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** This is a special case of the templated operator=. Its purpose is to + * prevent a default operator= from hiding the templated operator=. + */ + PermutationMatrix& operator=(const PermutationMatrix& other) + { + m_indices = other.m_indices; + return *this; + } + #endif + + /** const version of indices(). */ + const IndicesType& indices() const { return m_indices; } + /** \returns a reference to the stored array representing the permutation. */ + IndicesType& indices() { return m_indices; } + + + /**** multiplication helpers to hopefully get RVO ****/ + +#ifndef EIGEN_PARSED_BY_DOXYGEN + template + PermutationMatrix(const InverseImpl& other) + : m_indices(other.derived().nestedExpression().size()) + { + eigen_internal_assert(m_indices.size() <= NumTraits::highest()); + StorageIndex end = StorageIndex(m_indices.size()); + for (StorageIndex i=0; i + PermutationMatrix(internal::PermPermProduct_t, const Lhs& lhs, const Rhs& rhs) + : m_indices(lhs.indices().size()) + { + Base::assignProduct(lhs,rhs); + } +#endif + + protected: + + IndicesType m_indices; +}; + + +namespace internal { +template +struct traits,_PacketAccess> > + : traits > +{ + typedef PermutationStorage StorageKind; + typedef Map, _PacketAccess> IndicesType; + typedef _StorageIndex StorageIndex; + typedef void Scalar; +}; +} + +template +class Map,_PacketAccess> + : public PermutationBase,_PacketAccess> > +{ + typedef PermutationBase Base; + typedef internal::traits Traits; + public: + + #ifndef EIGEN_PARSED_BY_DOXYGEN + typedef typename Traits::IndicesType IndicesType; + typedef typename IndicesType::Scalar StorageIndex; + #endif + + inline Map(const StorageIndex* indicesPtr) + : m_indices(indicesPtr) + {} + + inline Map(const StorageIndex* indicesPtr, Index size) + : m_indices(indicesPtr,size) + {} + + /** Copies the other permutation into *this */ + template + Map& operator=(const PermutationBase& other) + { return Base::operator=(other.derived()); } + + /** Assignment from the Transpositions \a tr */ + template + Map& operator=(const TranspositionsBase& tr) + { return Base::operator=(tr.derived()); } + + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** This is a special case of the templated operator=. Its purpose is to + * prevent a default operator= from hiding the templated operator=. + */ + Map& operator=(const Map& other) + { + m_indices = other.m_indices; + return *this; + } + #endif + + /** const version of indices(). */ + const IndicesType& indices() const { return m_indices; } + /** \returns a reference to the stored array representing the permutation. */ + IndicesType& indices() { return m_indices; } + + protected: + + IndicesType m_indices; +}; + +template class TranspositionsWrapper; +namespace internal { +template +struct traits > +{ + typedef PermutationStorage StorageKind; + typedef void Scalar; + typedef typename _IndicesType::Scalar StorageIndex; + typedef _IndicesType IndicesType; + enum { + RowsAtCompileTime = _IndicesType::SizeAtCompileTime, + ColsAtCompileTime = _IndicesType::SizeAtCompileTime, + MaxRowsAtCompileTime = IndicesType::MaxSizeAtCompileTime, + MaxColsAtCompileTime = IndicesType::MaxSizeAtCompileTime, + Flags = 0 + }; +}; +} + +/** \class PermutationWrapper + * \ingroup Core_Module + * + * \brief Class to view a vector of integers as a permutation matrix + * + * \tparam _IndicesType the type of the vector of integer (can be any compatible expression) + * + * This class allows to view any vector expression of integers as a permutation matrix. + * + * \sa class PermutationBase, class PermutationMatrix + */ +template +class PermutationWrapper : public PermutationBase > +{ + typedef PermutationBase Base; + typedef internal::traits Traits; + public: + + #ifndef EIGEN_PARSED_BY_DOXYGEN + typedef typename Traits::IndicesType IndicesType; + #endif + + inline PermutationWrapper(const IndicesType& indices) + : m_indices(indices) + {} + + /** const version of indices(). */ + const typename internal::remove_all::type& + indices() const { return m_indices; } + + protected: + + typename IndicesType::Nested m_indices; +}; + + +/** \returns the matrix with the permutation applied to the columns. + */ +template +EIGEN_DEVICE_FUNC +const Product +operator*(const MatrixBase &matrix, + const PermutationBase& permutation) +{ + return Product + (matrix.derived(), permutation.derived()); +} + +/** \returns the matrix with the permutation applied to the rows. + */ +template +EIGEN_DEVICE_FUNC +const Product +operator*(const PermutationBase &permutation, + const MatrixBase& matrix) +{ + return Product + (permutation.derived(), matrix.derived()); +} + + +template +class InverseImpl + : public EigenBase > +{ + typedef typename PermutationType::PlainPermutationType PlainPermutationType; + typedef internal::traits PermTraits; + protected: + InverseImpl() {} + public: + typedef Inverse InverseType; + using EigenBase >::derived; + + #ifndef EIGEN_PARSED_BY_DOXYGEN + typedef typename PermutationType::DenseMatrixType DenseMatrixType; + enum { + RowsAtCompileTime = PermTraits::RowsAtCompileTime, + ColsAtCompileTime = PermTraits::ColsAtCompileTime, + MaxRowsAtCompileTime = PermTraits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = PermTraits::MaxColsAtCompileTime + }; + #endif + + #ifndef EIGEN_PARSED_BY_DOXYGEN + template + void evalTo(MatrixBase& other) const + { + other.setZero(); + for (Index i=0; i friend + const Product + operator*(const MatrixBase& matrix, const InverseType& trPerm) + { + return Product(matrix.derived(), trPerm.derived()); + } + + /** \returns the matrix with the inverse permutation applied to the rows. + */ + template + const Product + operator*(const MatrixBase& matrix) const + { + return Product(derived(), matrix.derived()); + } +}; + +template +const PermutationWrapper MatrixBase::asPermutation() const +{ + return derived(); +} + +namespace internal { + +template<> struct AssignmentKind { typedef EigenBase2EigenBase Kind; }; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_PERMUTATIONMATRIX_H diff --git a/3rdparty/eigen3/Eigen/src/Core/PlainObjectBase.h b/3rdparty/eigen3/Eigen/src/Core/PlainObjectBase.h new file mode 100644 index 0000000..1dc7e22 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/PlainObjectBase.h @@ -0,0 +1,1035 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_DENSESTORAGEBASE_H +#define EIGEN_DENSESTORAGEBASE_H + +#if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO) +# define EIGEN_INITIALIZE_COEFFS +# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(int i=0;i::quiet_NaN(); +#else +# undef EIGEN_INITIALIZE_COEFFS +# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED +#endif + +namespace Eigen { + +namespace internal { + +template struct check_rows_cols_for_overflow { + template + EIGEN_DEVICE_FUNC + static EIGEN_ALWAYS_INLINE void run(Index, Index) + { + } +}; + +template<> struct check_rows_cols_for_overflow { + template + EIGEN_DEVICE_FUNC + static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols) + { + // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242 + // we assume Index is signed + Index max_index = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed + bool error = (rows == 0 || cols == 0) ? false + : (rows > max_index / cols); + if (error) + throw_std_bad_alloc(); + } +}; + +template +struct conservative_resize_like_impl; + +template struct matrix_swap_impl; + +} // end namespace internal + +#ifdef EIGEN_PARSED_BY_DOXYGEN +namespace doxygen { + +// This is a workaround to doxygen not being able to understand the inheritance logic +// when it is hidden by the dense_xpr_base helper struct. +// Moreover, doxygen fails to include members that are not documented in the declaration body of +// MatrixBase if we inherits MatrixBase >, +// this is why we simply inherits MatrixBase, though this does not make sense. + +/** This class is just a workaround for Doxygen and it does not not actually exist. */ +template struct dense_xpr_base_dispatcher; +/** This class is just a workaround for Doxygen and it does not not actually exist. */ +template +struct dense_xpr_base_dispatcher > + : public MatrixBase {}; +/** This class is just a workaround for Doxygen and it does not not actually exist. */ +template +struct dense_xpr_base_dispatcher > + : public ArrayBase {}; + +} // namespace doxygen + +/** \class PlainObjectBase + * \ingroup Core_Module + * \brief %Dense storage base class for matrices and arrays. + * + * This class can be extended with the help of the plugin mechanism described on the page + * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_PLAINOBJECTBASE_PLUGIN. + * + * \tparam Derived is the derived type, e.g., a Matrix or Array + * + * \sa \ref TopicClassHierarchy + */ +template +class PlainObjectBase : public doxygen::dense_xpr_base_dispatcher +#else +template +class PlainObjectBase : public internal::dense_xpr_base::type +#endif +{ + public: + enum { Options = internal::traits::Options }; + typedef typename internal::dense_xpr_base::type Base; + + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Scalar Scalar; + + typedef typename internal::packet_traits::type PacketScalar; + typedef typename NumTraits::Real RealScalar; + typedef Derived DenseType; + + using Base::RowsAtCompileTime; + using Base::ColsAtCompileTime; + using Base::SizeAtCompileTime; + using Base::MaxRowsAtCompileTime; + using Base::MaxColsAtCompileTime; + using Base::MaxSizeAtCompileTime; + using Base::IsVectorAtCompileTime; + using Base::Flags; + + template friend class Eigen::Map; + friend class Eigen::Map; + typedef Eigen::Map MapType; + friend class Eigen::Map; + typedef const Eigen::Map ConstMapType; +#if EIGEN_MAX_ALIGN_BYTES>0 + // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice. + friend class Eigen::Map; + friend class Eigen::Map; +#endif + typedef Eigen::Map AlignedMapType; + typedef const Eigen::Map ConstAlignedMapType; + template struct StridedMapType { typedef Eigen::Map type; }; + template struct StridedConstMapType { typedef Eigen::Map type; }; + template struct StridedAlignedMapType { typedef Eigen::Map type; }; + template struct StridedConstAlignedMapType { typedef Eigen::Map type; }; + + protected: + DenseStorage m_storage; + + public: + enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits::Alignment>0) }; + EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) + + EIGEN_DEVICE_FUNC + Base& base() { return *static_cast(this); } + EIGEN_DEVICE_FUNC + const Base& base() const { return *static_cast(this); } + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); } + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); } + + /** This is an overloaded version of DenseCoeffsBase::coeff(Index,Index) const + * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts. + * + * See DenseCoeffsBase::coeff(Index) const for details. */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const + { + if(Flags & RowMajorBit) + return m_storage.data()[colId + rowId * m_storage.cols()]; + else // column-major + return m_storage.data()[rowId + colId * m_storage.rows()]; + } + + /** This is an overloaded version of DenseCoeffsBase::coeff(Index) const + * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts. + * + * See DenseCoeffsBase::coeff(Index) const for details. */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const + { + return m_storage.data()[index]; + } + + /** This is an overloaded version of DenseCoeffsBase::coeffRef(Index,Index) const + * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts. + * + * See DenseCoeffsBase::coeffRef(Index,Index) const for details. */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId) + { + if(Flags & RowMajorBit) + return m_storage.data()[colId + rowId * m_storage.cols()]; + else // column-major + return m_storage.data()[rowId + colId * m_storage.rows()]; + } + + /** This is an overloaded version of DenseCoeffsBase::coeffRef(Index) const + * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts. + * + * See DenseCoeffsBase::coeffRef(Index) const for details. */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) + { + return m_storage.data()[index]; + } + + /** This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index). + * It is provided for convenience. */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const + { + if(Flags & RowMajorBit) + return m_storage.data()[colId + rowId * m_storage.cols()]; + else // column-major + return m_storage.data()[rowId + colId * m_storage.rows()]; + } + + /** This is the const version of coeffRef(Index) which is thus synonym of coeff(Index). + * It is provided for convenience. */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const + { + return m_storage.data()[index]; + } + + /** \internal */ + template + EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const + { + return internal::ploadt + (m_storage.data() + (Flags & RowMajorBit + ? colId + rowId * m_storage.cols() + : rowId + colId * m_storage.rows())); + } + + /** \internal */ + template + EIGEN_STRONG_INLINE PacketScalar packet(Index index) const + { + return internal::ploadt(m_storage.data() + index); + } + + /** \internal */ + template + EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val) + { + internal::pstoret + (m_storage.data() + (Flags & RowMajorBit + ? colId + rowId * m_storage.cols() + : rowId + colId * m_storage.rows()), val); + } + + /** \internal */ + template + EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val) + { + internal::pstoret(m_storage.data() + index, val); + } + + /** \returns a const pointer to the data array of this matrix */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const + { return m_storage.data(); } + + /** \returns a pointer to the data array of this matrix */ + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data() + { return m_storage.data(); } + + /** Resizes \c *this to a \a rows x \a cols matrix. + * + * This method is intended for dynamic-size matrices, although it is legal to call it on any + * matrix as long as fixed dimensions are left unchanged. If you only want to change the number + * of rows and/or of columns, you can use resize(NoChange_t, Index), resize(Index, NoChange_t). + * + * If the current number of coefficients of \c *this exactly matches the + * product \a rows * \a cols, then no memory allocation is performed and + * the current values are left unchanged. In all other cases, including + * shrinking, the data is reallocated and all previous values are lost. + * + * Example: \include Matrix_resize_int_int.cpp + * Output: \verbinclude Matrix_resize_int_int.out + * + * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t) + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void resize(Index rows, Index cols) + { + eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime) + && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime) + && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime) + && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime) + && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array."); + internal::check_rows_cols_for_overflow::run(rows, cols); + #ifdef EIGEN_INITIALIZE_COEFFS + Index size = rows*cols; + bool size_changed = size != this->size(); + m_storage.resize(size, rows, cols); + if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + #else + m_storage.resize(rows*cols, rows, cols); + #endif + } + + /** Resizes \c *this to a vector of length \a size + * + * \only_for_vectors. This method does not work for + * partially dynamic matrices when the static dimension is anything other + * than 1. For example it will not work with Matrix. + * + * Example: \include Matrix_resize_int.cpp + * Output: \verbinclude Matrix_resize_int.out + * + * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t) + */ + EIGEN_DEVICE_FUNC + inline void resize(Index size) + { + EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase) + eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0); + #ifdef EIGEN_INITIALIZE_COEFFS + bool size_changed = size != this->size(); + #endif + if(RowsAtCompileTime == 1) + m_storage.resize(size, 1, size); + else + m_storage.resize(size, size, 1); + #ifdef EIGEN_INITIALIZE_COEFFS + if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + #endif + } + + /** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the special value \c NoChange + * as in the example below. + * + * Example: \include Matrix_resize_NoChange_int.cpp + * Output: \verbinclude Matrix_resize_NoChange_int.out + * + * \sa resize(Index,Index) + */ + EIGEN_DEVICE_FUNC + inline void resize(NoChange_t, Index cols) + { + resize(rows(), cols); + } + + /** Resizes the matrix, changing only the number of rows. For the parameter of type NoChange_t, just pass the special value \c NoChange + * as in the example below. + * + * Example: \include Matrix_resize_int_NoChange.cpp + * Output: \verbinclude Matrix_resize_int_NoChange.out + * + * \sa resize(Index,Index) + */ + EIGEN_DEVICE_FUNC + inline void resize(Index rows, NoChange_t) + { + resize(rows, cols()); + } + + /** Resizes \c *this to have the same dimensions as \a other. + * Takes care of doing all the checking that's needed. + * + * Note that copying a row-vector into a vector (and conversely) is allowed. + * The resizing, if any, is then done in the appropriate way so that row-vectors + * remain row-vectors and vectors remain vectors. + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void resizeLike(const EigenBase& _other) + { + const OtherDerived& other = _other.derived(); + internal::check_rows_cols_for_overflow::run(other.rows(), other.cols()); + const Index othersize = other.rows()*other.cols(); + if(RowsAtCompileTime == 1) + { + eigen_assert(other.rows() == 1 || other.cols() == 1); + resize(1, othersize); + } + else if(ColsAtCompileTime == 1) + { + eigen_assert(other.rows() == 1 || other.cols() == 1); + resize(othersize, 1); + } + else resize(other.rows(), other.cols()); + } + + /** Resizes the matrix to \a rows x \a cols while leaving old values untouched. + * + * The method is intended for matrices of dynamic size. If you only want to change the number + * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or + * conservativeResize(Index, NoChange_t). + * + * Matrices are resized relative to the top-left element. In case values need to be + * appended to the matrix they will be uninitialized. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols) + { + internal::conservative_resize_like_impl::run(*this, rows, cols); + } + + /** Resizes the matrix to \a rows x \a cols while leaving old values untouched. + * + * As opposed to conservativeResize(Index rows, Index cols), this version leaves + * the number of columns unchanged. + * + * In case the matrix is growing, new rows will be uninitialized. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t) + { + // Note: see the comment in conservativeResize(Index,Index) + conservativeResize(rows, cols()); + } + + /** Resizes the matrix to \a rows x \a cols while leaving old values untouched. + * + * As opposed to conservativeResize(Index rows, Index cols), this version leaves + * the number of rows unchanged. + * + * In case the matrix is growing, new columns will be uninitialized. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols) + { + // Note: see the comment in conservativeResize(Index,Index) + conservativeResize(rows(), cols); + } + + /** Resizes the vector to \a size while retaining old values. + * + * \only_for_vectors. This method does not work for + * partially dynamic matrices when the static dimension is anything other + * than 1. For example it will not work with Matrix. + * + * When values are appended, they will be uninitialized. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void conservativeResize(Index size) + { + internal::conservative_resize_like_impl::run(*this, size); + } + + /** Resizes the matrix to \a rows x \a cols of \c other, while leaving old values untouched. + * + * The method is intended for matrices of dynamic size. If you only want to change the number + * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or + * conservativeResize(Index, NoChange_t). + * + * Matrices are resized relative to the top-left element. In case values need to be + * appended to the matrix they will copied from \c other. + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase& other) + { + internal::conservative_resize_like_impl::run(*this, other); + } + + /** This is a special case of the templated operator=. Its purpose is to + * prevent a default operator= from hiding the templated operator=. + */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other) + { + return _set(other); + } + + /** \sa MatrixBase::lazyAssign() */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase& other) + { + _resize_to_match(other); + return Base::lazyAssign(other.derived()); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue& func) + { + resize(func.rows(), func.cols()); + return Base::operator=(func); + } + + // Prevent user from trying to instantiate PlainObjectBase objects + // by making all its constructor protected. See bug 1074. + protected: + + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE PlainObjectBase() : m_storage() + { +// _check_template_params(); +// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + } + +#ifndef EIGEN_PARSED_BY_DOXYGEN + // FIXME is it still needed ? + /** \internal */ + EIGEN_DEVICE_FUNC + explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert) + : m_storage(internal::constructor_without_unaligned_array_assert()) + { +// _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + } +#endif + +#if EIGEN_HAS_RVALUE_REFERENCES + EIGEN_DEVICE_FUNC + PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT + : m_storage( std::move(other.m_storage) ) + { + } + + EIGEN_DEVICE_FUNC + PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT + { + using std::swap; + swap(m_storage, other.m_storage); + return *this; + } +#endif + + /** Copy constructor */ + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other) + : Base(), m_storage(other.m_storage) { } + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols) + : m_storage(size, rows, cols) + { +// _check_template_params(); +// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + } + + /** \sa PlainObjectBase::operator=(const EigenBase&) */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase &other) + : m_storage() + { + _check_template_params(); + resizeLike(other); + _set_noalias(other); + } + + /** \sa PlainObjectBase::operator=(const EigenBase&) */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase &other) + : m_storage() + { + _check_template_params(); + resizeLike(other); + *this = other.derived(); + } + /** \brief Copy constructor with in-place evaluation */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue& other) + { + _check_template_params(); + // FIXME this does not automatically transpose vectors if necessary + resize(other.rows(), other.cols()); + other.evalTo(this->derived()); + } + + public: + + /** \brief Copies the generic expression \a other into *this. + * \copydetails DenseBase::operator=(const EigenBase &other) + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Derived& operator=(const EigenBase &other) + { + _resize_to_match(other); + Base::operator=(other.derived()); + return this->derived(); + } + + /** \name Map + * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects, + * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned + * \a data pointers. + * + * Here is an example using strides: + * \include Matrix_Map_stride.cpp + * Output: \verbinclude Matrix_Map_stride.out + * + * \see class Map + */ + //@{ + static inline ConstMapType Map(const Scalar* data) + { return ConstMapType(data); } + static inline MapType Map(Scalar* data) + { return MapType(data); } + static inline ConstMapType Map(const Scalar* data, Index size) + { return ConstMapType(data, size); } + static inline MapType Map(Scalar* data, Index size) + { return MapType(data, size); } + static inline ConstMapType Map(const Scalar* data, Index rows, Index cols) + { return ConstMapType(data, rows, cols); } + static inline MapType Map(Scalar* data, Index rows, Index cols) + { return MapType(data, rows, cols); } + + static inline ConstAlignedMapType MapAligned(const Scalar* data) + { return ConstAlignedMapType(data); } + static inline AlignedMapType MapAligned(Scalar* data) + { return AlignedMapType(data); } + static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size) + { return ConstAlignedMapType(data, size); } + static inline AlignedMapType MapAligned(Scalar* data, Index size) + { return AlignedMapType(data, size); } + static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols) + { return ConstAlignedMapType(data, rows, cols); } + static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols) + { return AlignedMapType(data, rows, cols); } + + template + static inline typename StridedConstMapType >::type Map(const Scalar* data, const Stride& stride) + { return typename StridedConstMapType >::type(data, stride); } + template + static inline typename StridedMapType >::type Map(Scalar* data, const Stride& stride) + { return typename StridedMapType >::type(data, stride); } + template + static inline typename StridedConstMapType >::type Map(const Scalar* data, Index size, const Stride& stride) + { return typename StridedConstMapType >::type(data, size, stride); } + template + static inline typename StridedMapType >::type Map(Scalar* data, Index size, const Stride& stride) + { return typename StridedMapType >::type(data, size, stride); } + template + static inline typename StridedConstMapType >::type Map(const Scalar* data, Index rows, Index cols, const Stride& stride) + { return typename StridedConstMapType >::type(data, rows, cols, stride); } + template + static inline typename StridedMapType >::type Map(Scalar* data, Index rows, Index cols, const Stride& stride) + { return typename StridedMapType >::type(data, rows, cols, stride); } + + template + static inline typename StridedConstAlignedMapType >::type MapAligned(const Scalar* data, const Stride& stride) + { return typename StridedConstAlignedMapType >::type(data, stride); } + template + static inline typename StridedAlignedMapType >::type MapAligned(Scalar* data, const Stride& stride) + { return typename StridedAlignedMapType >::type(data, stride); } + template + static inline typename StridedConstAlignedMapType >::type MapAligned(const Scalar* data, Index size, const Stride& stride) + { return typename StridedConstAlignedMapType >::type(data, size, stride); } + template + static inline typename StridedAlignedMapType >::type MapAligned(Scalar* data, Index size, const Stride& stride) + { return typename StridedAlignedMapType >::type(data, size, stride); } + template + static inline typename StridedConstAlignedMapType >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride& stride) + { return typename StridedConstAlignedMapType >::type(data, rows, cols, stride); } + template + static inline typename StridedAlignedMapType >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride& stride) + { return typename StridedAlignedMapType >::type(data, rows, cols, stride); } + //@} + + using Base::setConstant; + EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val); + EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val); + + using Base::setZero; + EIGEN_DEVICE_FUNC Derived& setZero(Index size); + EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols); + + using Base::setOnes; + EIGEN_DEVICE_FUNC Derived& setOnes(Index size); + EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols); + + using Base::setRandom; + Derived& setRandom(Index size); + Derived& setRandom(Index rows, Index cols); + + #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN + #include EIGEN_PLAINOBJECTBASE_PLUGIN + #endif + + protected: + /** \internal Resizes *this in preparation for assigning \a other to it. + * Takes care of doing all the checking that's needed. + * + * Note that copying a row-vector into a vector (and conversely) is allowed. + * The resizing, if any, is then done in the appropriate way so that row-vectors + * remain row-vectors and vectors remain vectors. + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase& other) + { + #ifdef EIGEN_NO_AUTOMATIC_RESIZING + eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size()) + : (rows() == other.rows() && cols() == other.cols()))) + && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined"); + EIGEN_ONLY_USED_FOR_DEBUG(other); + #else + resizeLike(other); + #endif + } + + /** + * \brief Copies the value of the expression \a other into \c *this with automatic resizing. + * + * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized), + * it will be initialized. + * + * Note that copying a row-vector into a vector (and conversely) is allowed. + * The resizing, if any, is then done in the appropriate way so that row-vectors + * remain row-vectors and vectors remain vectors. + * + * \sa operator=(const MatrixBase&), _set_noalias() + * + * \internal + */ + // aliasing is dealt once in internall::call_assignment + // so at this stage we have to assume aliasing... and resising has to be done later. + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Derived& _set(const DenseBase& other) + { + internal::call_assignment(this->derived(), other.derived()); + return this->derived(); + } + + /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which + * is the case when creating a new matrix) so one can enforce lazy evaluation. + * + * \sa operator=(const MatrixBase&), _set() + */ + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase& other) + { + // I don't think we need this resize call since the lazyAssign will anyways resize + // and lazyAssign will be called by the assign selector. + //_resize_to_match(other); + // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because + // it wouldn't allow to copy a row-vector into a column-vector. + internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op()); + return this->derived(); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if::type* = 0) + { + EIGEN_STATIC_ASSERT(bool(NumTraits::IsInteger) && + bool(NumTraits::IsInteger), + FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED) + resize(rows,cols); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if::type* = 0) + { + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2) + m_storage.data()[0] = Scalar(val0); + m_storage.data()[1] = Scalar(val1); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1, + typename internal::enable_if< (!internal::is_same::value) + && (internal::is_same::value) + && (internal::is_same::value) + && Base::SizeAtCompileTime==2,T1>::type* = 0) + { + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2) + m_storage.data()[0] = Scalar(val0); + m_storage.data()[1] = Scalar(val1); + } + + // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array, + // then the argument is meant to be the size of the object. + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if< (Base::SizeAtCompileTime!=1 || !internal::is_convertible::value) + && ((!internal::is_same::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0) + { + // NOTE MSVC 2008 complains if we directly put bool(NumTraits::IsInteger) as the EIGEN_STATIC_ASSERT argument. + const bool is_integer = NumTraits::IsInteger; + EIGEN_UNUSED_VARIABLE(is_integer); + EIGEN_STATIC_ASSERT(is_integer, + FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED) + resize(size); + } + + // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitely converted) + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if::value,T>::type* = 0) + { + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1) + m_storage.data()[0] = val0; + } + + // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type match the index type) + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const Index& val0, + typename internal::enable_if< (!internal::is_same::value) + && (internal::is_same::value) + && Base::SizeAtCompileTime==1 + && internal::is_convertible::value,T*>::type* = 0) + { + EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1) + m_storage.data()[0] = Scalar(val0); + } + + // Initialize a fixed size matrix from a pointer to raw data + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const Scalar* data){ + this->_set_noalias(ConstMapType(data)); + } + + // Initialize an arbitrary matrix from a dense expression + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const DenseBase& other){ + this->_set_noalias(other); + } + + // Initialize an arbitrary matrix from an object convertible to the Derived type. + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const Derived& other){ + this->_set_noalias(other); + } + + // Initialize an arbitrary matrix from a generic Eigen expression + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const EigenBase& other){ + this->derived() = other; + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const ReturnByValue& other) + { + resize(other.rows(), other.cols()); + other.evalTo(this->derived()); + } + + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const RotationBase& r) + { + this->derived() = r; + } + + // For fixed-size Array + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const Scalar& val0, + typename internal::enable_if< Base::SizeAtCompileTime!=Dynamic + && Base::SizeAtCompileTime!=1 + && internal::is_convertible::value + && internal::is_same::XprKind,ArrayXpr>::value,T>::type* = 0) + { + Base::setConstant(val0); + } + + // For fixed-size Array + template + EIGEN_DEVICE_FUNC + EIGEN_STRONG_INLINE void _init1(const Index& val0, + typename internal::enable_if< (!internal::is_same::value) + && (internal::is_same::value) + && Base::SizeAtCompileTime!=Dynamic + && Base::SizeAtCompileTime!=1 + && internal::is_convertible::value + && internal::is_same::XprKind,ArrayXpr>::value,T*>::type* = 0) + { + Base::setConstant(val0); + } + + template + friend struct internal::matrix_swap_impl; + + public: + +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** \internal + * \brief Override DenseBase::swap() since for dynamic-sized matrices + * of same type it is enough to swap the data pointers. + */ + template + EIGEN_DEVICE_FUNC + void swap(DenseBase & other) + { + enum { SwapPointers = internal::is_same::value && Base::SizeAtCompileTime==Dynamic }; + internal::matrix_swap_impl::run(this->derived(), other.derived()); + } + + /** \internal + * \brief const version forwarded to DenseBase::swap + */ + template + EIGEN_DEVICE_FUNC + void swap(DenseBase const & other) + { Base::swap(other.derived()); } + + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE void _check_template_params() + { + EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor) + && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0) + && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0)) + && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0)) + && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0)) + && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0)) + && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic) + && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic) + && (Options & (DontAlign|RowMajor)) == Options), + INVALID_MATRIX_TEMPLATE_PARAMETERS) + } + + enum { IsPlainObjectBase = 1 }; +#endif +}; + +namespace internal { + +template +struct conservative_resize_like_impl +{ + static void run(DenseBase& _this, Index rows, Index cols) + { + if (_this.rows() == rows && _this.cols() == cols) return; + EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived) + + if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows + (!Derived::IsRowMajor && _this.rows() == rows) ) // column-major and we change only the number of columns + { + internal::check_rows_cols_for_overflow::run(rows, cols); + _this.derived().m_storage.conservativeResize(rows*cols,rows,cols); + } + else + { + // The storage order does not allow us to use reallocation. + typename Derived::PlainObject tmp(rows,cols); + const Index common_rows = numext::mini(rows, _this.rows()); + const Index common_cols = numext::mini(cols, _this.cols()); + tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols); + _this.derived().swap(tmp); + } + } + + static void run(DenseBase& _this, const DenseBase& other) + { + if (_this.rows() == other.rows() && _this.cols() == other.cols()) return; + + // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index), + // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the + // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or + // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like + // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good. + EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived) + EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived) + + if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows + (!Derived::IsRowMajor && _this.rows() == other.rows()) ) // column-major and we change only the number of columns + { + const Index new_rows = other.rows() - _this.rows(); + const Index new_cols = other.cols() - _this.cols(); + _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols()); + if (new_rows>0) + _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows); + else if (new_cols>0) + _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols); + } + else + { + // The storage order does not allow us to use reallocation. + typename Derived::PlainObject tmp(other); + const Index common_rows = numext::mini(tmp.rows(), _this.rows()); + const Index common_cols = numext::mini(tmp.cols(), _this.cols()); + tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols); + _this.derived().swap(tmp); + } + } +}; + +// Here, the specialization for vectors inherits from the general matrix case +// to allow calling .conservativeResize(rows,cols) on vectors. +template +struct conservative_resize_like_impl + : conservative_resize_like_impl +{ + using conservative_resize_like_impl::run; + + static void run(DenseBase& _this, Index size) + { + const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size; + const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1; + _this.derived().m_storage.conservativeResize(size,new_rows,new_cols); + } + + static void run(DenseBase& _this, const DenseBase& other) + { + if (_this.rows() == other.rows() && _this.cols() == other.cols()) return; + + const Index num_new_elements = other.size() - _this.size(); + + const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows(); + const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1; + _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols); + + if (num_new_elements > 0) + _this.tail(num_new_elements) = other.tail(num_new_elements); + } +}; + +template +struct matrix_swap_impl +{ + EIGEN_DEVICE_FUNC + static inline void run(MatrixTypeA& a, MatrixTypeB& b) + { + a.base().swap(b); + } +}; + +template +struct matrix_swap_impl +{ + EIGEN_DEVICE_FUNC + static inline void run(MatrixTypeA& a, MatrixTypeB& b) + { + static_cast(a).m_storage.swap(static_cast(b).m_storage); + } +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_DENSESTORAGEBASE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Product.h b/3rdparty/eigen3/Eigen/src/Core/Product.h new file mode 100644 index 0000000..676c480 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Product.h @@ -0,0 +1,186 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2011 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_PRODUCT_H +#define EIGEN_PRODUCT_H + +namespace Eigen { + +template class ProductImpl; + +namespace internal { + +template +struct traits > +{ + typedef typename remove_all::type LhsCleaned; + typedef typename remove_all::type RhsCleaned; + typedef traits LhsTraits; + typedef traits RhsTraits; + + typedef MatrixXpr XprKind; + + typedef typename ScalarBinaryOpTraits::Scalar, typename traits::Scalar>::ReturnType Scalar; + typedef typename product_promote_storage_type::ret>::ret StorageKind; + typedef typename promote_index_type::type StorageIndex; + + enum { + RowsAtCompileTime = LhsTraits::RowsAtCompileTime, + ColsAtCompileTime = RhsTraits::ColsAtCompileTime, + MaxRowsAtCompileTime = LhsTraits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = RhsTraits::MaxColsAtCompileTime, + + // FIXME: only needed by GeneralMatrixMatrixTriangular + InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsTraits::ColsAtCompileTime, RhsTraits::RowsAtCompileTime), + + // The storage order is somewhat arbitrary here. The correct one will be determined through the evaluator. + Flags = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? RowMajorBit + : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0 + : ( ((LhsTraits::Flags&NoPreferredStorageOrderBit) && (RhsTraits::Flags&RowMajorBit)) + || ((RhsTraits::Flags&NoPreferredStorageOrderBit) && (LhsTraits::Flags&RowMajorBit)) ) ? RowMajorBit + : NoPreferredStorageOrderBit + }; +}; + +} // end namespace internal + +/** \class Product + * \ingroup Core_Module + * + * \brief Expression of the product of two arbitrary matrices or vectors + * + * \tparam _Lhs the type of the left-hand side expression + * \tparam _Rhs the type of the right-hand side expression + * + * This class represents an expression of the product of two arbitrary matrices. + * + * The other template parameters are: + * \tparam Option can be DefaultProduct, AliasFreeProduct, or LazyProduct + * + */ +template +class Product : public ProductImpl<_Lhs,_Rhs,Option, + typename internal::product_promote_storage_type::StorageKind, + typename internal::traits<_Rhs>::StorageKind, + internal::product_type<_Lhs,_Rhs>::ret>::ret> +{ + public: + + typedef _Lhs Lhs; + typedef _Rhs Rhs; + + typedef typename ProductImpl< + Lhs, Rhs, Option, + typename internal::product_promote_storage_type::StorageKind, + typename internal::traits::StorageKind, + internal::product_type::ret>::ret>::Base Base; + EIGEN_GENERIC_PUBLIC_INTERFACE(Product) + + typedef typename internal::ref_selector::type LhsNested; + typedef typename internal::ref_selector::type RhsNested; + typedef typename internal::remove_all::type LhsNestedCleaned; + typedef typename internal::remove_all::type RhsNestedCleaned; + + EIGEN_DEVICE_FUNC Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs) + { + eigen_assert(lhs.cols() == rhs.rows() + && "invalid matrix product" + && "if you wanted a coeff-wise or a dot product use the respective explicit functions"); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const { return m_lhs.rows(); } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const { return m_rhs.cols(); } + + EIGEN_DEVICE_FUNC const LhsNestedCleaned& lhs() const { return m_lhs; } + EIGEN_DEVICE_FUNC const RhsNestedCleaned& rhs() const { return m_rhs; } + + protected: + + LhsNested m_lhs; + RhsNested m_rhs; +}; + +namespace internal { + +template::ret> +class dense_product_base + : public internal::dense_xpr_base >::type +{}; + +/** Convertion to scalar for inner-products */ +template +class dense_product_base + : public internal::dense_xpr_base >::type +{ + typedef Product ProductXpr; + typedef typename internal::dense_xpr_base::type Base; +public: + using Base::derived; + typedef typename Base::Scalar Scalar; + + EIGEN_STRONG_INLINE operator const Scalar() const + { + return internal::evaluator(derived()).coeff(0,0); + } +}; + +} // namespace internal + +// Generic API dispatcher +template +class ProductImpl : public internal::generic_xpr_base, MatrixXpr, StorageKind>::type +{ + public: + typedef typename internal::generic_xpr_base, MatrixXpr, StorageKind>::type Base; +}; + +template +class ProductImpl + : public internal::dense_product_base +{ + typedef Product Derived; + + public: + + typedef typename internal::dense_product_base Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Derived) + protected: + enum { + IsOneByOne = (RowsAtCompileTime == 1 || RowsAtCompileTime == Dynamic) && + (ColsAtCompileTime == 1 || ColsAtCompileTime == Dynamic), + EnableCoeff = IsOneByOne || Option==LazyProduct + }; + + public: + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index row, Index col) const + { + EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS); + eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) ); + + return internal::evaluator(derived()).coeff(row,col); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index i) const + { + EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS); + eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) ); + + return internal::evaluator(derived()).coeff(i); + } + + +}; + +} // end namespace Eigen + +#endif // EIGEN_PRODUCT_H diff --git a/3rdparty/eigen3/Eigen/src/Core/ProductEvaluators.h b/3rdparty/eigen3/Eigen/src/Core/ProductEvaluators.h new file mode 100644 index 0000000..9b99bd7 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/ProductEvaluators.h @@ -0,0 +1,1112 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2008 Benoit Jacob +// Copyright (C) 2008-2010 Gael Guennebaud +// Copyright (C) 2011 Jitse Niesen +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + + +#ifndef EIGEN_PRODUCTEVALUATORS_H +#define EIGEN_PRODUCTEVALUATORS_H + +namespace Eigen { + +namespace internal { + +/** \internal + * Evaluator of a product expression. + * Since products require special treatments to handle all possible cases, + * we simply deffer the evaluation logic to a product_evaluator class + * which offers more partial specialization possibilities. + * + * \sa class product_evaluator + */ +template +struct evaluator > + : public product_evaluator > +{ + typedef Product XprType; + typedef product_evaluator Base; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {} +}; + +// Catch "scalar * ( A * B )" and transform it to "(A*scalar) * B" +// TODO we should apply that rule only if that's really helpful +template +struct evaluator_assume_aliasing, + const CwiseNullaryOp, Plain1>, + const Product > > +{ + static const bool value = true; +}; +template +struct evaluator, + const CwiseNullaryOp, Plain1>, + const Product > > + : public evaluator > +{ + typedef CwiseBinaryOp, + const CwiseNullaryOp, Plain1>, + const Product > XprType; + typedef evaluator > Base; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) + : Base(xpr.lhs().functor().m_other * xpr.rhs().lhs() * xpr.rhs().rhs()) + {} +}; + + +template +struct evaluator, DiagIndex> > + : public evaluator, DiagIndex> > +{ + typedef Diagonal, DiagIndex> XprType; + typedef evaluator, DiagIndex> > Base; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) + : Base(Diagonal, DiagIndex>( + Product(xpr.nestedExpression().lhs(), xpr.nestedExpression().rhs()), + xpr.index() )) + {} +}; + + +// Helper class to perform a matrix product with the destination at hand. +// Depending on the sizes of the factors, there are different evaluation strategies +// as controlled by internal::product_type. +template< typename Lhs, typename Rhs, + typename LhsShape = typename evaluator_traits::Shape, + typename RhsShape = typename evaluator_traits::Shape, + int ProductType = internal::product_type::value> +struct generic_product_impl; + +template +struct evaluator_assume_aliasing > { + static const bool value = true; +}; + +// This is the default evaluator implementation for products: +// It creates a temporary and call generic_product_impl +template +struct product_evaluator, ProductTag, LhsShape, RhsShape> + : public evaluator::PlainObject> +{ + typedef Product XprType; + typedef typename XprType::PlainObject PlainObject; + typedef evaluator Base; + enum { + Flags = Base::Flags | EvalBeforeNestingBit + }; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + explicit product_evaluator(const XprType& xpr) + : m_result(xpr.rows(), xpr.cols()) + { + ::new (static_cast(this)) Base(m_result); + +// FIXME shall we handle nested_eval here?, +// if so, then we must take care at removing the call to nested_eval in the specializations (e.g., in permutation_matrix_product, transposition_matrix_product, etc.) +// typedef typename internal::nested_eval::type LhsNested; +// typedef typename internal::nested_eval::type RhsNested; +// typedef typename internal::remove_all::type LhsNestedCleaned; +// typedef typename internal::remove_all::type RhsNestedCleaned; +// +// const LhsNested lhs(xpr.lhs()); +// const RhsNested rhs(xpr.rhs()); +// +// generic_product_impl::evalTo(m_result, lhs, rhs); + + generic_product_impl::evalTo(m_result, xpr.lhs(), xpr.rhs()); + } + +protected: + PlainObject m_result; +}; + +// The following three shortcuts are enabled only if the scalar types match excatly. +// TODO: we could enable them for different scalar types when the product is not vectorized. + +// Dense = Product +template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar> +struct Assignment, internal::assign_op, Dense2Dense, + typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type> +{ + typedef Product SrcXprType; + static EIGEN_STRONG_INLINE + void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op &) + { + Index dstRows = src.rows(); + Index dstCols = src.cols(); + if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) + dst.resize(dstRows, dstCols); + // FIXME shall we handle nested_eval here? + generic_product_impl::evalTo(dst, src.lhs(), src.rhs()); + } +}; + +// Dense += Product +template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar> +struct Assignment, internal::add_assign_op, Dense2Dense, + typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type> +{ + typedef Product SrcXprType; + static EIGEN_STRONG_INLINE + void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op &) + { + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); + // FIXME shall we handle nested_eval here? + generic_product_impl::addTo(dst, src.lhs(), src.rhs()); + } +}; + +// Dense -= Product +template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar> +struct Assignment, internal::sub_assign_op, Dense2Dense, + typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type> +{ + typedef Product SrcXprType; + static EIGEN_STRONG_INLINE + void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op &) + { + eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); + // FIXME shall we handle nested_eval here? + generic_product_impl::subTo(dst, src.lhs(), src.rhs()); + } +}; + + +// Dense ?= scalar * Product +// TODO we should apply that rule if that's really helpful +// for instance, this is not good for inner products +template< typename DstXprType, typename Lhs, typename Rhs, typename AssignFunc, typename Scalar, typename ScalarBis, typename Plain> +struct Assignment, const CwiseNullaryOp,Plain>, + const Product >, AssignFunc, Dense2Dense> +{ + typedef CwiseBinaryOp, + const CwiseNullaryOp,Plain>, + const Product > SrcXprType; + static EIGEN_STRONG_INLINE + void run(DstXprType &dst, const SrcXprType &src, const AssignFunc& func) + { + call_assignment_no_alias(dst, (src.lhs().functor().m_other * src.rhs().lhs())*src.rhs().rhs(), func); + } +}; + +//---------------------------------------- +// Catch "Dense ?= xpr + Product<>" expression to save one temporary +// FIXME we could probably enable these rules for any product, i.e., not only Dense and DefaultProduct + +template +struct evaluator_assume_aliasing::Scalar>, const OtherXpr, + const Product >, DenseShape > { + static const bool value = true; +}; + +template +struct evaluator_assume_aliasing::Scalar>, const OtherXpr, + const Product >, DenseShape > { + static const bool value = true; +}; + +template +struct assignment_from_xpr_op_product +{ + template + static EIGEN_STRONG_INLINE + void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/) + { + call_assignment_no_alias(dst, src.lhs(), Func1()); + call_assignment_no_alias(dst, src.rhs(), Func2()); + } +}; + +#define EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(ASSIGN_OP,BINOP,ASSIGN_OP2) \ + template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar> \ + struct Assignment, const OtherXpr, \ + const Product >, internal::ASSIGN_OP, Dense2Dense> \ + : assignment_from_xpr_op_product, internal::ASSIGN_OP, internal::ASSIGN_OP2 > \ + {} + +EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op, scalar_sum_op,add_assign_op); +EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_sum_op,add_assign_op); +EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_sum_op,sub_assign_op); + +EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op, scalar_difference_op,sub_assign_op); +EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_difference_op,sub_assign_op); +EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_difference_op,add_assign_op); + +//---------------------------------------- + +template +struct generic_product_impl +{ + template + static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + dst.coeffRef(0,0) = (lhs.transpose().cwiseProduct(rhs)).sum(); + } + + template + static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + dst.coeffRef(0,0) += (lhs.transpose().cwiseProduct(rhs)).sum(); + } + + template + static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { dst.coeffRef(0,0) -= (lhs.transpose().cwiseProduct(rhs)).sum(); } +}; + + +/*********************************************************************** +* Implementation of outer dense * dense vector product +***********************************************************************/ + +// Column major result +template +void outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const false_type&) +{ + evaluator rhsEval(rhs); + typename nested_eval::type actual_lhs(lhs); + // FIXME if cols is large enough, then it might be useful to make sure that lhs is sequentially stored + // FIXME not very good if rhs is real and lhs complex while alpha is real too + const Index cols = dst.cols(); + for (Index j=0; j +void outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const true_type&) +{ + evaluator lhsEval(lhs); + typename nested_eval::type actual_rhs(rhs); + // FIXME if rows is large enough, then it might be useful to make sure that rhs is sequentially stored + // FIXME not very good if lhs is real and rhs complex while alpha is real too + const Index rows = dst.rows(); + for (Index i=0; i +struct generic_product_impl +{ + template struct is_row_major : internal::conditional<(int(T::Flags)&RowMajorBit), internal::true_type, internal::false_type>::type {}; + typedef typename Product::Scalar Scalar; + + // TODO it would be nice to be able to exploit our *_assign_op functors for that purpose + struct set { template void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() = src; } }; + struct add { template void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; } }; + struct sub { template void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } }; + struct adds { + Scalar m_scale; + explicit adds(const Scalar& s) : m_scale(s) {} + template void operator()(const Dst& dst, const Src& src) const { + dst.const_cast_derived() += m_scale * src; + } + }; + + template + static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + internal::outer_product_selector_run(dst, lhs, rhs, set(), is_row_major()); + } + + template + static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + internal::outer_product_selector_run(dst, lhs, rhs, add(), is_row_major()); + } + + template + static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + internal::outer_product_selector_run(dst, lhs, rhs, sub(), is_row_major()); + } + + template + static EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) + { + internal::outer_product_selector_run(dst, lhs, rhs, adds(alpha), is_row_major()); + } + +}; + + +// This base class provides default implementations for evalTo, addTo, subTo, in terms of scaleAndAddTo +template +struct generic_product_impl_base +{ + typedef typename Product::Scalar Scalar; + + template + static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { dst.setZero(); scaleAndAddTo(dst, lhs, rhs, Scalar(1)); } + + template + static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { scaleAndAddTo(dst,lhs, rhs, Scalar(1)); } + + template + static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { scaleAndAddTo(dst, lhs, rhs, Scalar(-1)); } + + template + static EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) + { Derived::scaleAndAddTo(dst,lhs,rhs,alpha); } + +}; + +template +struct generic_product_impl + : generic_product_impl_base > +{ + typedef typename nested_eval::type LhsNested; + typedef typename nested_eval::type RhsNested; + typedef typename Product::Scalar Scalar; + enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight }; + typedef typename internal::remove_all::type>::type MatrixType; + + template + static EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) + { + LhsNested actual_lhs(lhs); + RhsNested actual_rhs(rhs); + internal::gemv_dense_selector::HasUsableDirectAccess) + >::run(actual_lhs, actual_rhs, dst, alpha); + } +}; + +template +struct generic_product_impl +{ + typedef typename Product::Scalar Scalar; + + template + static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + // Same as: dst.noalias() = lhs.lazyProduct(rhs); + // but easier on the compiler side + call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op()); + } + + template + static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + // dst.noalias() += lhs.lazyProduct(rhs); + call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op()); + } + + template + static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) + { + // dst.noalias() -= lhs.lazyProduct(rhs); + call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op()); + } + +// template +// static inline void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) +// { dst.noalias() += alpha * lhs.lazyProduct(rhs); } +}; + +// This specialization enforces the use of a coefficient-based evaluation strategy +template +struct generic_product_impl + : generic_product_impl {}; + +// Case 2: Evaluate coeff by coeff +// +// This is mostly taken from CoeffBasedProduct.h +// The main difference is that we add an extra argument to the etor_product_*_impl::run() function +// for the inner dimension of the product, because evaluator object do not know their size. + +template +struct etor_product_coeff_impl; + +template +struct etor_product_packet_impl; + +template +struct product_evaluator, ProductTag, DenseShape, DenseShape> + : evaluator_base > +{ + typedef Product XprType; + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE + explicit product_evaluator(const XprType& xpr) + : m_lhs(xpr.lhs()), + m_rhs(xpr.rhs()), + m_lhsImpl(m_lhs), // FIXME the creation of the evaluator objects should result in a no-op, but check that! + m_rhsImpl(m_rhs), // Moreover, they are only useful for the packet path, so we could completely disable them when not needed, + // or perhaps declare them on the fly on the packet method... We have experiment to check what's best. + m_innerDim(xpr.lhs().cols()) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits::MulCost); + EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits::AddCost); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); +#if 0 + std::cerr << "LhsOuterStrideBytes= " << LhsOuterStrideBytes << "\n"; + std::cerr << "RhsOuterStrideBytes= " << RhsOuterStrideBytes << "\n"; + std::cerr << "LhsAlignment= " << LhsAlignment << "\n"; + std::cerr << "RhsAlignment= " << RhsAlignment << "\n"; + std::cerr << "CanVectorizeLhs= " << CanVectorizeLhs << "\n"; + std::cerr << "CanVectorizeRhs= " << CanVectorizeRhs << "\n"; + std::cerr << "CanVectorizeInner= " << CanVectorizeInner << "\n"; + std::cerr << "EvalToRowMajor= " << EvalToRowMajor << "\n"; + std::cerr << "Alignment= " << Alignment << "\n"; + std::cerr << "Flags= " << Flags << "\n"; +#endif + } + + // Everything below here is taken from CoeffBasedProduct.h + + typedef typename internal::nested_eval::type LhsNested; + typedef typename internal::nested_eval::type RhsNested; + + typedef typename internal::remove_all::type LhsNestedCleaned; + typedef typename internal::remove_all::type RhsNestedCleaned; + + typedef evaluator LhsEtorType; + typedef evaluator RhsEtorType; + + enum { + RowsAtCompileTime = LhsNestedCleaned::RowsAtCompileTime, + ColsAtCompileTime = RhsNestedCleaned::ColsAtCompileTime, + InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsNestedCleaned::ColsAtCompileTime, RhsNestedCleaned::RowsAtCompileTime), + MaxRowsAtCompileTime = LhsNestedCleaned::MaxRowsAtCompileTime, + MaxColsAtCompileTime = RhsNestedCleaned::MaxColsAtCompileTime + }; + + typedef typename find_best_packet::type LhsVecPacketType; + typedef typename find_best_packet::type RhsVecPacketType; + + enum { + + LhsCoeffReadCost = LhsEtorType::CoeffReadCost, + RhsCoeffReadCost = RhsEtorType::CoeffReadCost, + CoeffReadCost = InnerSize==0 ? NumTraits::ReadCost + : InnerSize == Dynamic ? HugeCost + : InnerSize * (NumTraits::MulCost + LhsCoeffReadCost + RhsCoeffReadCost) + + (InnerSize - 1) * NumTraits::AddCost, + + Unroll = CoeffReadCost <= EIGEN_UNROLLING_LIMIT, + + LhsFlags = LhsEtorType::Flags, + RhsFlags = RhsEtorType::Flags, + + LhsRowMajor = LhsFlags & RowMajorBit, + RhsRowMajor = RhsFlags & RowMajorBit, + + LhsVecPacketSize = unpacket_traits::size, + RhsVecPacketSize = unpacket_traits::size, + + // Here, we don't care about alignment larger than the usable packet size. + LhsAlignment = EIGEN_PLAIN_ENUM_MIN(LhsEtorType::Alignment,LhsVecPacketSize*int(sizeof(typename LhsNestedCleaned::Scalar))), + RhsAlignment = EIGEN_PLAIN_ENUM_MIN(RhsEtorType::Alignment,RhsVecPacketSize*int(sizeof(typename RhsNestedCleaned::Scalar))), + + SameType = is_same::value, + + CanVectorizeRhs = bool(RhsRowMajor) && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime!=1), + CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime!=1), + + EvalToRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1 + : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0 + : (bool(RhsRowMajor) && !CanVectorizeLhs), + + Flags = ((unsigned int)(LhsFlags | RhsFlags) & HereditaryBits & ~RowMajorBit) + | (EvalToRowMajor ? RowMajorBit : 0) + // TODO enable vectorization for mixed types + | (SameType && (CanVectorizeLhs || CanVectorizeRhs) ? PacketAccessBit : 0) + | (XprType::IsVectorAtCompileTime ? LinearAccessBit : 0), + + LhsOuterStrideBytes = int(LhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename LhsNestedCleaned::Scalar)), + RhsOuterStrideBytes = int(RhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename RhsNestedCleaned::Scalar)), + + Alignment = bool(CanVectorizeLhs) ? (LhsOuterStrideBytes<=0 || (int(LhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,LhsAlignment))!=0 ? 0 : LhsAlignment) + : bool(CanVectorizeRhs) ? (RhsOuterStrideBytes<=0 || (int(RhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,RhsAlignment))!=0 ? 0 : RhsAlignment) + : 0, + + /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside + * of Product. If the Product itself is not a packet-access expression, there is still a chance that the inner + * loop of the product might be vectorized. This is the meaning of CanVectorizeInner. Since it doesn't affect + * the Flags, it is safe to make this value depend on ActualPacketAccessBit, that doesn't affect the ABI. + */ + CanVectorizeInner = SameType + && LhsRowMajor + && (!RhsRowMajor) + && (LhsFlags & RhsFlags & ActualPacketAccessBit) + && (InnerSize % packet_traits::size == 0) + }; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index row, Index col) const + { + return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum(); + } + + /* Allow index-based non-packet access. It is impossible though to allow index-based packed access, + * which is why we don't set the LinearAccessBit. + * TODO: this seems possible when the result is a vector + */ + EIGEN_DEVICE_FUNC const CoeffReturnType coeff(Index index) const + { + const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index; + const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0; + return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum(); + } + + template + const PacketType packet(Index row, Index col) const + { + PacketType res; + typedef etor_product_packet_impl PacketImpl; + PacketImpl::run(row, col, m_lhsImpl, m_rhsImpl, m_innerDim, res); + return res; + } + + template + const PacketType packet(Index index) const + { + const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index; + const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0; + return packet(row,col); + } + +protected: + typename internal::add_const_on_value_type::type m_lhs; + typename internal::add_const_on_value_type::type m_rhs; + + LhsEtorType m_lhsImpl; + RhsEtorType m_rhsImpl; + + // TODO: Get rid of m_innerDim if known at compile time + Index m_innerDim; +}; + +template +struct product_evaluator, LazyCoeffBasedProductMode, DenseShape, DenseShape> + : product_evaluator, CoeffBasedProductMode, DenseShape, DenseShape> +{ + typedef Product XprType; + typedef Product BaseProduct; + typedef product_evaluator Base; + enum { + Flags = Base::Flags | EvalBeforeNestingBit + }; + EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr) + : Base(BaseProduct(xpr.lhs(),xpr.rhs())) + {} +}; + +/**************************************** +*** Coeff based product, Packet path *** +****************************************/ + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res) + { + etor_product_packet_impl::run(row, col, lhs, rhs, innerDim, res); + res = pmadd(pset1(lhs.coeff(row, Index(UnrollingIndex-1))), rhs.template packet(Index(UnrollingIndex-1), col), res); + } +}; + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res) + { + etor_product_packet_impl::run(row, col, lhs, rhs, innerDim, res); + res = pmadd(lhs.template packet(row, Index(UnrollingIndex-1)), pset1(rhs.coeff(Index(UnrollingIndex-1), col)), res); + } +}; + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res) + { + res = pmul(pset1(lhs.coeff(row, Index(0))),rhs.template packet(Index(0), col)); + } +}; + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res) + { + res = pmul(lhs.template packet(row, Index(0)), pset1(rhs.coeff(Index(0), col))); + } +}; + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res) + { + res = pset1(typename unpacket_traits::type(0)); + } +}; + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res) + { + res = pset1(typename unpacket_traits::type(0)); + } +}; + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res) + { + res = pset1(typename unpacket_traits::type(0)); + for(Index i = 0; i < innerDim; ++i) + res = pmadd(pset1(lhs.coeff(row, i)), rhs.template packet(i, col), res); + } +}; + +template +struct etor_product_packet_impl +{ + static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res) + { + res = pset1(typename unpacket_traits::type(0)); + for(Index i = 0; i < innerDim; ++i) + res = pmadd(lhs.template packet(row, i), pset1(rhs.coeff(i, col)), res); + } +}; + + +/*************************************************************************** +* Triangular products +***************************************************************************/ +template +struct triangular_product_impl; + +template +struct generic_product_impl + : generic_product_impl_base > +{ + typedef typename Product::Scalar Scalar; + + template + static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) + { + triangular_product_impl + ::run(dst, lhs.nestedExpression(), rhs, alpha); + } +}; + +template +struct generic_product_impl +: generic_product_impl_base > +{ + typedef typename Product::Scalar Scalar; + + template + static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) + { + triangular_product_impl::run(dst, lhs, rhs.nestedExpression(), alpha); + } +}; + + +/*************************************************************************** +* SelfAdjoint products +***************************************************************************/ +template +struct selfadjoint_product_impl; + +template +struct generic_product_impl + : generic_product_impl_base > +{ + typedef typename Product::Scalar Scalar; + + template + static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) + { + selfadjoint_product_impl::run(dst, lhs.nestedExpression(), rhs, alpha); + } +}; + +template +struct generic_product_impl +: generic_product_impl_base > +{ + typedef typename Product::Scalar Scalar; + + template + static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) + { + selfadjoint_product_impl::run(dst, lhs, rhs.nestedExpression(), alpha); + } +}; + + +/*************************************************************************** +* Diagonal products +***************************************************************************/ + +template +struct diagonal_product_evaluator_base + : evaluator_base +{ + typedef typename ScalarBinaryOpTraits::ReturnType Scalar; +public: + enum { + CoeffReadCost = NumTraits::MulCost + evaluator::CoeffReadCost + evaluator::CoeffReadCost, + + MatrixFlags = evaluator::Flags, + DiagFlags = evaluator::Flags, + _StorageOrder = MatrixFlags & RowMajorBit ? RowMajor : ColMajor, + _ScalarAccessOnDiag = !((int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheLeft) + ||(int(_StorageOrder) == RowMajor && int(ProductOrder) == OnTheRight)), + _SameTypes = is_same::value, + // FIXME currently we need same types, but in the future the next rule should be the one + //_Vectorizable = bool(int(MatrixFlags)&PacketAccessBit) && ((!_PacketOnDiag) || (_SameTypes && bool(int(DiagFlags)&PacketAccessBit))), + _Vectorizable = bool(int(MatrixFlags)&PacketAccessBit) && _SameTypes && (_ScalarAccessOnDiag || (bool(int(DiagFlags)&PacketAccessBit))), + _LinearAccessMask = (MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1) ? LinearAccessBit : 0, + Flags = ((HereditaryBits|_LinearAccessMask) & (unsigned int)(MatrixFlags)) | (_Vectorizable ? PacketAccessBit : 0), + Alignment = evaluator::Alignment, + + AsScalarProduct = (DiagonalType::SizeAtCompileTime==1) + || (DiagonalType::SizeAtCompileTime==Dynamic && MatrixType::RowsAtCompileTime==1 && ProductOrder==OnTheLeft) + || (DiagonalType::SizeAtCompileTime==Dynamic && MatrixType::ColsAtCompileTime==1 && ProductOrder==OnTheRight) + }; + + diagonal_product_evaluator_base(const MatrixType &mat, const DiagonalType &diag) + : m_diagImpl(diag), m_matImpl(mat) + { + EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits::MulCost); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index idx) const + { + if(AsScalarProduct) + return m_diagImpl.coeff(0) * m_matImpl.coeff(idx); + else + return m_diagImpl.coeff(idx) * m_matImpl.coeff(idx); + } + +protected: + template + EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::true_type) const + { + return internal::pmul(m_matImpl.template packet(row, col), + internal::pset1(m_diagImpl.coeff(id))); + } + + template + EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::false_type) const + { + enum { + InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime, + DiagonalPacketLoadMode = EIGEN_PLAIN_ENUM_MIN(LoadMode,((InnerSize%16) == 0) ? int(Aligned16) : int(evaluator::Alignment)) // FIXME hardcoded 16!! + }; + return internal::pmul(m_matImpl.template packet(row, col), + m_diagImpl.template packet(id)); + } + + evaluator m_diagImpl; + evaluator m_matImpl; +}; + +// diagonal * dense +template +struct product_evaluator, ProductTag, DiagonalShape, DenseShape> + : diagonal_product_evaluator_base, OnTheLeft> +{ + typedef diagonal_product_evaluator_base, OnTheLeft> Base; + using Base::m_diagImpl; + using Base::m_matImpl; + using Base::coeff; + typedef typename Base::Scalar Scalar; + + typedef Product XprType; + typedef typename XprType::PlainObject PlainObject; + + enum { + StorageOrder = int(Rhs::Flags) & RowMajorBit ? RowMajor : ColMajor + }; + + EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr) + : Base(xpr.rhs(), xpr.lhs().diagonal()) + { + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const + { + return m_diagImpl.coeff(row) * m_matImpl.coeff(row, col); + } + +#ifndef __CUDACC__ + template + EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const + { + // FIXME: NVCC used to complain about the template keyword, but we have to check whether this is still the case. + // See also similar calls below. + return this->template packet_impl(row,col, row, + typename internal::conditional::type()); + } + + template + EIGEN_STRONG_INLINE PacketType packet(Index idx) const + { + return packet(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx); + } +#endif +}; + +// dense * diagonal +template +struct product_evaluator, ProductTag, DenseShape, DiagonalShape> + : diagonal_product_evaluator_base, OnTheRight> +{ + typedef diagonal_product_evaluator_base, OnTheRight> Base; + using Base::m_diagImpl; + using Base::m_matImpl; + using Base::coeff; + typedef typename Base::Scalar Scalar; + + typedef Product XprType; + typedef typename XprType::PlainObject PlainObject; + + enum { StorageOrder = int(Lhs::Flags) & RowMajorBit ? RowMajor : ColMajor }; + + EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr) + : Base(xpr.lhs(), xpr.rhs().diagonal()) + { + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const + { + return m_matImpl.coeff(row, col) * m_diagImpl.coeff(col); + } + +#ifndef __CUDACC__ + template + EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const + { + return this->template packet_impl(row,col, col, + typename internal::conditional::type()); + } + + template + EIGEN_STRONG_INLINE PacketType packet(Index idx) const + { + return packet(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx); + } +#endif +}; + +/*************************************************************************** +* Products with permutation matrices +***************************************************************************/ + +/** \internal + * \class permutation_matrix_product + * Internal helper class implementing the product between a permutation matrix and a matrix. + * This class is specialized for DenseShape below and for SparseShape in SparseCore/SparsePermutation.h + */ +template +struct permutation_matrix_product; + +template +struct permutation_matrix_product +{ + typedef typename nested_eval::type MatrixType; + typedef typename remove_all::type MatrixTypeCleaned; + + template + static inline void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr) + { + MatrixType mat(xpr); + const Index n = Side==OnTheLeft ? mat.rows() : mat.cols(); + // FIXME we need an is_same for expression that is not sensitive to constness. For instance + // is_same_xpr, Block >::value should be true. + //if(is_same::value && extract_data(dst) == extract_data(mat)) + if(is_same_dense(dst, mat)) + { + // apply the permutation inplace + Matrix mask(perm.size()); + mask.fill(false); + Index r = 0; + while(r < perm.size()) + { + // search for the next seed + while(r=perm.size()) + break; + // we got one, let's follow it until we are back to the seed + Index k0 = r++; + Index kPrev = k0; + mask.coeffRef(k0) = true; + for(Index k=perm.indices().coeff(k0); k!=k0; k=perm.indices().coeff(k)) + { + Block(dst, k) + .swap(Block + (dst,((Side==OnTheLeft) ^ Transposed) ? k0 : kPrev)); + + mask.coeffRef(k) = true; + kPrev = k; + } + } + } + else + { + for(Index i = 0; i < n; ++i) + { + Block + (dst, ((Side==OnTheLeft) ^ Transposed) ? perm.indices().coeff(i) : i) + + = + + Block + (mat, ((Side==OnTheRight) ^ Transposed) ? perm.indices().coeff(i) : i); + } + } + } +}; + +template +struct generic_product_impl +{ + template + static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) + { + permutation_matrix_product::run(dst, lhs, rhs); + } +}; + +template +struct generic_product_impl +{ + template + static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) + { + permutation_matrix_product::run(dst, rhs, lhs); + } +}; + +template +struct generic_product_impl, Rhs, PermutationShape, MatrixShape, ProductTag> +{ + template + static void evalTo(Dest& dst, const Inverse& lhs, const Rhs& rhs) + { + permutation_matrix_product::run(dst, lhs.nestedExpression(), rhs); + } +}; + +template +struct generic_product_impl, MatrixShape, PermutationShape, ProductTag> +{ + template + static void evalTo(Dest& dst, const Lhs& lhs, const Inverse& rhs) + { + permutation_matrix_product::run(dst, rhs.nestedExpression(), lhs); + } +}; + + +/*************************************************************************** +* Products with transpositions matrices +***************************************************************************/ + +// FIXME could we unify Transpositions and Permutation into a single "shape"?? + +/** \internal + * \class transposition_matrix_product + * Internal helper class implementing the product between a permutation matrix and a matrix. + */ +template +struct transposition_matrix_product +{ + typedef typename nested_eval::type MatrixType; + typedef typename remove_all::type MatrixTypeCleaned; + + template + static inline void run(Dest& dst, const TranspositionType& tr, const ExpressionType& xpr) + { + MatrixType mat(xpr); + typedef typename TranspositionType::StorageIndex StorageIndex; + const Index size = tr.size(); + StorageIndex j = 0; + + if(!is_same_dense(dst,mat)) + dst = mat; + + for(Index k=(Transposed?size-1:0) ; Transposed?k>=0:k +struct generic_product_impl +{ + template + static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) + { + transposition_matrix_product::run(dst, lhs, rhs); + } +}; + +template +struct generic_product_impl +{ + template + static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) + { + transposition_matrix_product::run(dst, rhs, lhs); + } +}; + + +template +struct generic_product_impl, Rhs, TranspositionsShape, MatrixShape, ProductTag> +{ + template + static void evalTo(Dest& dst, const Transpose& lhs, const Rhs& rhs) + { + transposition_matrix_product::run(dst, lhs.nestedExpression(), rhs); + } +}; + +template +struct generic_product_impl, MatrixShape, TranspositionsShape, ProductTag> +{ + template + static void evalTo(Dest& dst, const Lhs& lhs, const Transpose& rhs) + { + transposition_matrix_product::run(dst, rhs.nestedExpression(), lhs); + } +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_PRODUCT_EVALUATORS_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Random.h b/3rdparty/eigen3/Eigen/src/Core/Random.h new file mode 100644 index 0000000..6faf789 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Random.h @@ -0,0 +1,182 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_RANDOM_H +#define EIGEN_RANDOM_H + +namespace Eigen { + +namespace internal { + +template struct scalar_random_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op) + inline const Scalar operator() () const { return random(); } +}; + +template +struct functor_traits > +{ enum { Cost = 5 * NumTraits::MulCost, PacketAccess = false, IsRepeatable = false }; }; + +} // end namespace internal + +/** \returns a random matrix expression + * + * Numbers are uniformly spread through their whole definition range for integer types, + * and in the [-1:1] range for floating point scalar types. + * + * The parameters \a rows and \a cols are the number of rows and of columns of + * the returned matrix. Must be compatible with this MatrixBase type. + * + * \not_reentrant + * + * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, + * it is redundant to pass \a rows and \a cols as arguments, so Random() should be used + * instead. + * + * + * Example: \include MatrixBase_random_int_int.cpp + * Output: \verbinclude MatrixBase_random_int_int.out + * + * This expression has the "evaluate before nesting" flag so that it will be evaluated into + * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected + * behavior with expressions involving random matrices. + * + * See DenseBase::NullaryExpr(Index, const CustomNullaryOp&) for an example using C++11 random generators. + * + * \sa DenseBase::setRandom(), DenseBase::Random(Index), DenseBase::Random() + */ +template +inline const typename DenseBase::RandomReturnType +DenseBase::Random(Index rows, Index cols) +{ + return NullaryExpr(rows, cols, internal::scalar_random_op()); +} + +/** \returns a random vector expression + * + * Numbers are uniformly spread through their whole definition range for integer types, + * and in the [-1:1] range for floating point scalar types. + * + * The parameter \a size is the size of the returned vector. + * Must be compatible with this MatrixBase type. + * + * \only_for_vectors + * \not_reentrant + * + * This variant is meant to be used for dynamic-size vector types. For fixed-size types, + * it is redundant to pass \a size as argument, so Random() should be used + * instead. + * + * Example: \include MatrixBase_random_int.cpp + * Output: \verbinclude MatrixBase_random_int.out + * + * This expression has the "evaluate before nesting" flag so that it will be evaluated into + * a temporary vector whenever it is nested in a larger expression. This prevents unexpected + * behavior with expressions involving random matrices. + * + * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random() + */ +template +inline const typename DenseBase::RandomReturnType +DenseBase::Random(Index size) +{ + return NullaryExpr(size, internal::scalar_random_op()); +} + +/** \returns a fixed-size random matrix or vector expression + * + * Numbers are uniformly spread through their whole definition range for integer types, + * and in the [-1:1] range for floating point scalar types. + * + * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you + * need to use the variants taking size arguments. + * + * Example: \include MatrixBase_random.cpp + * Output: \verbinclude MatrixBase_random.out + * + * This expression has the "evaluate before nesting" flag so that it will be evaluated into + * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected + * behavior with expressions involving random matrices. + * + * \not_reentrant + * + * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random(Index) + */ +template +inline const typename DenseBase::RandomReturnType +DenseBase::Random() +{ + return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op()); +} + +/** Sets all coefficients in this expression to random values. + * + * Numbers are uniformly spread through their whole definition range for integer types, + * and in the [-1:1] range for floating point scalar types. + * + * \not_reentrant + * + * Example: \include MatrixBase_setRandom.cpp + * Output: \verbinclude MatrixBase_setRandom.out + * + * \sa class CwiseNullaryOp, setRandom(Index), setRandom(Index,Index) + */ +template +inline Derived& DenseBase::setRandom() +{ + return *this = Random(rows(), cols()); +} + +/** Resizes to the given \a newSize, and sets all coefficients in this expression to random values. + * + * Numbers are uniformly spread through their whole definition range for integer types, + * and in the [-1:1] range for floating point scalar types. + * + * \only_for_vectors + * \not_reentrant + * + * Example: \include Matrix_setRandom_int.cpp + * Output: \verbinclude Matrix_setRandom_int.out + * + * \sa DenseBase::setRandom(), setRandom(Index,Index), class CwiseNullaryOp, DenseBase::Random() + */ +template +EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setRandom(Index newSize) +{ + resize(newSize); + return setRandom(); +} + +/** Resizes to the given size, and sets all coefficients in this expression to random values. + * + * Numbers are uniformly spread through their whole definition range for integer types, + * and in the [-1:1] range for floating point scalar types. + * + * \not_reentrant + * + * \param rows the new number of rows + * \param cols the new number of columns + * + * Example: \include Matrix_setRandom_int_int.cpp + * Output: \verbinclude Matrix_setRandom_int_int.out + * + * \sa DenseBase::setRandom(), setRandom(Index), class CwiseNullaryOp, DenseBase::Random() + */ +template +EIGEN_STRONG_INLINE Derived& +PlainObjectBase::setRandom(Index rows, Index cols) +{ + resize(rows, cols); + return setRandom(); +} + +} // end namespace Eigen + +#endif // EIGEN_RANDOM_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Redux.h b/3rdparty/eigen3/Eigen/src/Core/Redux.h new file mode 100644 index 0000000..760e9f8 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Redux.h @@ -0,0 +1,505 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_REDUX_H +#define EIGEN_REDUX_H + +namespace Eigen { + +namespace internal { + +// TODO +// * implement other kind of vectorization +// * factorize code + +/*************************************************************************** +* Part 1 : the logic deciding a strategy for vectorization and unrolling +***************************************************************************/ + +template +struct redux_traits +{ +public: + typedef typename find_best_packet::type PacketType; + enum { + PacketSize = unpacket_traits::size, + InnerMaxSize = int(Derived::IsRowMajor) + ? Derived::MaxColsAtCompileTime + : Derived::MaxRowsAtCompileTime + }; + + enum { + MightVectorize = (int(Derived::Flags)&ActualPacketAccessBit) + && (functor_traits::PacketAccess), + MayLinearVectorize = bool(MightVectorize) && (int(Derived::Flags)&LinearAccessBit), + MaySliceVectorize = bool(MightVectorize) && int(InnerMaxSize)>=3*PacketSize + }; + +public: + enum { + Traversal = int(MayLinearVectorize) ? int(LinearVectorizedTraversal) + : int(MaySliceVectorize) ? int(SliceVectorizedTraversal) + : int(DefaultTraversal) + }; + +public: + enum { + Cost = Derived::SizeAtCompileTime == Dynamic ? HugeCost + : Derived::SizeAtCompileTime * Derived::CoeffReadCost + (Derived::SizeAtCompileTime-1) * functor_traits::Cost, + UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize)) + }; + +public: + enum { + Unrolling = Cost <= UnrollingLimit ? CompleteUnrolling : NoUnrolling + }; + +#ifdef EIGEN_DEBUG_ASSIGN + static void debug() + { + std::cerr << "Xpr: " << typeid(typename Derived::XprType).name() << std::endl; + std::cerr.setf(std::ios::hex, std::ios::basefield); + EIGEN_DEBUG_VAR(Derived::Flags) + std::cerr.unsetf(std::ios::hex); + EIGEN_DEBUG_VAR(InnerMaxSize) + EIGEN_DEBUG_VAR(PacketSize) + EIGEN_DEBUG_VAR(MightVectorize) + EIGEN_DEBUG_VAR(MayLinearVectorize) + EIGEN_DEBUG_VAR(MaySliceVectorize) + EIGEN_DEBUG_VAR(Traversal) + EIGEN_DEBUG_VAR(UnrollingLimit) + EIGEN_DEBUG_VAR(Unrolling) + std::cerr << std::endl; + } +#endif +}; + +/*************************************************************************** +* Part 2 : unrollers +***************************************************************************/ + +/*** no vectorization ***/ + +template +struct redux_novec_unroller +{ + enum { + HalfLength = Length/2 + }; + + typedef typename Derived::Scalar Scalar; + + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func) + { + return func(redux_novec_unroller::run(mat,func), + redux_novec_unroller::run(mat,func)); + } +}; + +template +struct redux_novec_unroller +{ + enum { + outer = Start / Derived::InnerSizeAtCompileTime, + inner = Start % Derived::InnerSizeAtCompileTime + }; + + typedef typename Derived::Scalar Scalar; + + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func&) + { + return mat.coeffByOuterInner(outer, inner); + } +}; + +// This is actually dead code and will never be called. It is required +// to prevent false warnings regarding failed inlining though +// for 0 length run() will never be called at all. +template +struct redux_novec_unroller +{ + typedef typename Derived::Scalar Scalar; + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE Scalar run(const Derived&, const Func&) { return Scalar(); } +}; + +/*** vectorization ***/ + +template +struct redux_vec_unroller +{ + enum { + PacketSize = redux_traits::PacketSize, + HalfLength = Length/2 + }; + + typedef typename Derived::Scalar Scalar; + typedef typename redux_traits::PacketType PacketScalar; + + static EIGEN_STRONG_INLINE PacketScalar run(const Derived &mat, const Func& func) + { + return func.packetOp( + redux_vec_unroller::run(mat,func), + redux_vec_unroller::run(mat,func) ); + } +}; + +template +struct redux_vec_unroller +{ + enum { + index = Start * redux_traits::PacketSize, + outer = index / int(Derived::InnerSizeAtCompileTime), + inner = index % int(Derived::InnerSizeAtCompileTime), + alignment = Derived::Alignment + }; + + typedef typename Derived::Scalar Scalar; + typedef typename redux_traits::PacketType PacketScalar; + + static EIGEN_STRONG_INLINE PacketScalar run(const Derived &mat, const Func&) + { + return mat.template packetByOuterInner(outer, inner); + } +}; + +/*************************************************************************** +* Part 3 : implementation of all cases +***************************************************************************/ + +template::Traversal, + int Unrolling = redux_traits::Unrolling +> +struct redux_impl; + +template +struct redux_impl +{ + typedef typename Derived::Scalar Scalar; + EIGEN_DEVICE_FUNC + static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func) + { + eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); + Scalar res; + res = mat.coeffByOuterInner(0, 0); + for(Index i = 1; i < mat.innerSize(); ++i) + res = func(res, mat.coeffByOuterInner(0, i)); + for(Index i = 1; i < mat.outerSize(); ++i) + for(Index j = 0; j < mat.innerSize(); ++j) + res = func(res, mat.coeffByOuterInner(i, j)); + return res; + } +}; + +template +struct redux_impl + : public redux_novec_unroller +{}; + +template +struct redux_impl +{ + typedef typename Derived::Scalar Scalar; + typedef typename redux_traits::PacketType PacketScalar; + + static Scalar run(const Derived &mat, const Func& func) + { + const Index size = mat.size(); + + const Index packetSize = redux_traits::PacketSize; + const int packetAlignment = unpacket_traits::alignment; + enum { + alignment0 = (bool(Derived::Flags & DirectAccessBit) && bool(packet_traits::AlignedOnScalar)) ? int(packetAlignment) : int(Unaligned), + alignment = EIGEN_PLAIN_ENUM_MAX(alignment0, Derived::Alignment) + }; + const Index alignedStart = internal::first_default_aligned(mat.nestedExpression()); + const Index alignedSize2 = ((size-alignedStart)/(2*packetSize))*(2*packetSize); + const Index alignedSize = ((size-alignedStart)/(packetSize))*(packetSize); + const Index alignedEnd2 = alignedStart + alignedSize2; + const Index alignedEnd = alignedStart + alignedSize; + Scalar res; + if(alignedSize) + { + PacketScalar packet_res0 = mat.template packet(alignedStart); + if(alignedSize>packetSize) // we have at least two packets to partly unroll the loop + { + PacketScalar packet_res1 = mat.template packet(alignedStart+packetSize); + for(Index index = alignedStart + 2*packetSize; index < alignedEnd2; index += 2*packetSize) + { + packet_res0 = func.packetOp(packet_res0, mat.template packet(index)); + packet_res1 = func.packetOp(packet_res1, mat.template packet(index+packetSize)); + } + + packet_res0 = func.packetOp(packet_res0,packet_res1); + if(alignedEnd>alignedEnd2) + packet_res0 = func.packetOp(packet_res0, mat.template packet(alignedEnd2)); + } + res = func.predux(packet_res0); + + for(Index index = 0; index < alignedStart; ++index) + res = func(res,mat.coeff(index)); + + for(Index index = alignedEnd; index < size; ++index) + res = func(res,mat.coeff(index)); + } + else // too small to vectorize anything. + // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize. + { + res = mat.coeff(0); + for(Index index = 1; index < size; ++index) + res = func(res,mat.coeff(index)); + } + + return res; + } +}; + +// NOTE: for SliceVectorizedTraversal we simply bypass unrolling +template +struct redux_impl +{ + typedef typename Derived::Scalar Scalar; + typedef typename redux_traits::PacketType PacketType; + + EIGEN_DEVICE_FUNC static Scalar run(const Derived &mat, const Func& func) + { + eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); + const Index innerSize = mat.innerSize(); + const Index outerSize = mat.outerSize(); + enum { + packetSize = redux_traits::PacketSize + }; + const Index packetedInnerSize = ((innerSize)/packetSize)*packetSize; + Scalar res; + if(packetedInnerSize) + { + PacketType packet_res = mat.template packet(0,0); + for(Index j=0; j(j,i)); + + res = func.predux(packet_res); + for(Index j=0; j::run(mat, func); + } + + return res; + } +}; + +template +struct redux_impl +{ + typedef typename Derived::Scalar Scalar; + + typedef typename redux_traits::PacketType PacketScalar; + enum { + PacketSize = redux_traits::PacketSize, + Size = Derived::SizeAtCompileTime, + VectorizedSize = (Size / PacketSize) * PacketSize + }; + EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func) + { + eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); + if (VectorizedSize > 0) { + Scalar res = func.predux(redux_vec_unroller::run(mat,func)); + if (VectorizedSize != Size) + res = func(res,redux_novec_unroller::run(mat,func)); + return res; + } + else { + return redux_novec_unroller::run(mat,func); + } + } +}; + +// evaluator adaptor +template +class redux_evaluator +{ +public: + typedef _XprType XprType; + EIGEN_DEVICE_FUNC explicit redux_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {} + + typedef typename XprType::Scalar Scalar; + typedef typename XprType::CoeffReturnType CoeffReturnType; + typedef typename XprType::PacketScalar PacketScalar; + typedef typename XprType::PacketReturnType PacketReturnType; + + enum { + MaxRowsAtCompileTime = XprType::MaxRowsAtCompileTime, + MaxColsAtCompileTime = XprType::MaxColsAtCompileTime, + // TODO we should not remove DirectAccessBit and rather find an elegant way to query the alignment offset at runtime from the evaluator + Flags = evaluator::Flags & ~DirectAccessBit, + IsRowMajor = XprType::IsRowMajor, + SizeAtCompileTime = XprType::SizeAtCompileTime, + InnerSizeAtCompileTime = XprType::InnerSizeAtCompileTime, + CoeffReadCost = evaluator::CoeffReadCost, + Alignment = evaluator::Alignment + }; + + EIGEN_DEVICE_FUNC Index rows() const { return m_xpr.rows(); } + EIGEN_DEVICE_FUNC Index cols() const { return m_xpr.cols(); } + EIGEN_DEVICE_FUNC Index size() const { return m_xpr.size(); } + EIGEN_DEVICE_FUNC Index innerSize() const { return m_xpr.innerSize(); } + EIGEN_DEVICE_FUNC Index outerSize() const { return m_xpr.outerSize(); } + + EIGEN_DEVICE_FUNC + CoeffReturnType coeff(Index row, Index col) const + { return m_evaluator.coeff(row, col); } + + EIGEN_DEVICE_FUNC + CoeffReturnType coeff(Index index) const + { return m_evaluator.coeff(index); } + + template + PacketType packet(Index row, Index col) const + { return m_evaluator.template packet(row, col); } + + template + PacketType packet(Index index) const + { return m_evaluator.template packet(index); } + + EIGEN_DEVICE_FUNC + CoeffReturnType coeffByOuterInner(Index outer, Index inner) const + { return m_evaluator.coeff(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); } + + template + PacketType packetByOuterInner(Index outer, Index inner) const + { return m_evaluator.template packet(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); } + + const XprType & nestedExpression() const { return m_xpr; } + +protected: + internal::evaluator m_evaluator; + const XprType &m_xpr; +}; + +} // end namespace internal + +/*************************************************************************** +* Part 4 : public API +***************************************************************************/ + + +/** \returns the result of a full redux operation on the whole matrix or vector using \a func + * + * The template parameter \a BinaryOp is the type of the functor \a func which must be + * an associative operator. Both current C++98 and C++11 functor styles are handled. + * + * \sa DenseBase::sum(), DenseBase::minCoeff(), DenseBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise() + */ +template +template +EIGEN_STRONG_INLINE typename internal::traits::Scalar +DenseBase::redux(const Func& func) const +{ + eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix"); + + typedef typename internal::redux_evaluator ThisEvaluator; + ThisEvaluator thisEval(derived()); + + return internal::redux_impl::run(thisEval, func); +} + +/** \returns the minimum of all coefficients of \c *this. + * \warning the result is undefined if \c *this contains NaN. + */ +template +EIGEN_STRONG_INLINE typename internal::traits::Scalar +DenseBase::minCoeff() const +{ + return derived().redux(Eigen::internal::scalar_min_op()); +} + +/** \returns the maximum of all coefficients of \c *this. + * \warning the result is undefined if \c *this contains NaN. + */ +template +EIGEN_STRONG_INLINE typename internal::traits::Scalar +DenseBase::maxCoeff() const +{ + return derived().redux(Eigen::internal::scalar_max_op()); +} + +/** \returns the sum of all coefficients of \c *this + * + * If \c *this is empty, then the value 0 is returned. + * + * \sa trace(), prod(), mean() + */ +template +EIGEN_STRONG_INLINE typename internal::traits::Scalar +DenseBase::sum() const +{ + if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0)) + return Scalar(0); + return derived().redux(Eigen::internal::scalar_sum_op()); +} + +/** \returns the mean of all coefficients of *this +* +* \sa trace(), prod(), sum() +*/ +template +EIGEN_STRONG_INLINE typename internal::traits::Scalar +DenseBase::mean() const +{ +#ifdef __INTEL_COMPILER + #pragma warning push + #pragma warning ( disable : 2259 ) +#endif + return Scalar(derived().redux(Eigen::internal::scalar_sum_op())) / Scalar(this->size()); +#ifdef __INTEL_COMPILER + #pragma warning pop +#endif +} + +/** \returns the product of all coefficients of *this + * + * Example: \include MatrixBase_prod.cpp + * Output: \verbinclude MatrixBase_prod.out + * + * \sa sum(), mean(), trace() + */ +template +EIGEN_STRONG_INLINE typename internal::traits::Scalar +DenseBase::prod() const +{ + if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0)) + return Scalar(1); + return derived().redux(Eigen::internal::scalar_product_op()); +} + +/** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal. + * + * \c *this can be any matrix, not necessarily square. + * + * \sa diagonal(), sum() + */ +template +EIGEN_STRONG_INLINE typename internal::traits::Scalar +MatrixBase::trace() const +{ + return derived().diagonal().sum(); +} + +} // end namespace Eigen + +#endif // EIGEN_REDUX_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Ref.h b/3rdparty/eigen3/Eigen/src/Core/Ref.h new file mode 100644 index 0000000..9c6e3c5 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Ref.h @@ -0,0 +1,283 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2012 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_REF_H +#define EIGEN_REF_H + +namespace Eigen { + +namespace internal { + +template +struct traits > + : public traits > +{ + typedef _PlainObjectType PlainObjectType; + typedef _StrideType StrideType; + enum { + Options = _Options, + Flags = traits >::Flags | NestByRefBit, + Alignment = traits >::Alignment + }; + + template struct match { + enum { + HasDirectAccess = internal::has_direct_access::ret, + StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)), + InnerStrideMatch = int(StrideType::InnerStrideAtCompileTime)==int(Dynamic) + || int(StrideType::InnerStrideAtCompileTime)==int(Derived::InnerStrideAtCompileTime) + || (int(StrideType::InnerStrideAtCompileTime)==0 && int(Derived::InnerStrideAtCompileTime)==1), + OuterStrideMatch = Derived::IsVectorAtCompileTime + || int(StrideType::OuterStrideAtCompileTime)==int(Dynamic) || int(StrideType::OuterStrideAtCompileTime)==int(Derived::OuterStrideAtCompileTime), + // NOTE, this indirection of evaluator::Alignment is needed + // to workaround a very strange bug in MSVC related to the instantiation + // of has_*ary_operator in evaluator. + // This line is surprisingly very sensitive. For instance, simply adding parenthesis + // as "DerivedAlignment = (int(evaluator::Alignment))," will make MSVC fail... + DerivedAlignment = int(evaluator::Alignment), + AlignmentMatch = (int(traits::Alignment)==int(Unaligned)) || (DerivedAlignment >= int(Alignment)), // FIXME the first condition is not very clear, it should be replaced by the required alignment + ScalarTypeMatch = internal::is_same::value, + MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch && AlignmentMatch && ScalarTypeMatch + }; + typedef typename internal::conditional::type type; + }; + +}; + +template +struct traits > : public traits {}; + +} + +template class RefBase + : public MapBase +{ + typedef typename internal::traits::PlainObjectType PlainObjectType; + typedef typename internal::traits::StrideType StrideType; + +public: + + typedef MapBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(RefBase) + + EIGEN_DEVICE_FUNC inline Index innerStride() const + { + return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1; + } + + EIGEN_DEVICE_FUNC inline Index outerStride() const + { + return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer() + : IsVectorAtCompileTime ? this->size() + : int(Flags)&RowMajorBit ? this->cols() + : this->rows(); + } + + EIGEN_DEVICE_FUNC RefBase() + : Base(0,RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime), + // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values: + m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime, + StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime) + {} + + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase) + +protected: + + typedef Stride StrideBase; + + template + EIGEN_DEVICE_FUNC void construct(Expression& expr) + { + EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(PlainObjectType,Expression); + + if(PlainObjectType::RowsAtCompileTime==1) + { + eigen_assert(expr.rows()==1 || expr.cols()==1); + ::new (static_cast(this)) Base(expr.data(), 1, expr.size()); + } + else if(PlainObjectType::ColsAtCompileTime==1) + { + eigen_assert(expr.rows()==1 || expr.cols()==1); + ::new (static_cast(this)) Base(expr.data(), expr.size(), 1); + } + else + ::new (static_cast(this)) Base(expr.data(), expr.rows(), expr.cols()); + + if(Expression::IsVectorAtCompileTime && (!PlainObjectType::IsVectorAtCompileTime) && ((Expression::Flags&RowMajorBit)!=(PlainObjectType::Flags&RowMajorBit))) + ::new (&m_stride) StrideBase(expr.innerStride(), StrideType::InnerStrideAtCompileTime==0?0:1); + else + ::new (&m_stride) StrideBase(StrideType::OuterStrideAtCompileTime==0?0:expr.outerStride(), + StrideType::InnerStrideAtCompileTime==0?0:expr.innerStride()); + } + + StrideBase m_stride; +}; + +/** \class Ref + * \ingroup Core_Module + * + * \brief A matrix or vector expression mapping an existing expression + * + * \tparam PlainObjectType the equivalent matrix type of the mapped data + * \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned. + * The default is \c #Unaligned. + * \tparam StrideType optionally specifies strides. By default, Ref implies a contiguous storage along the inner dimension (inner stride==1), + * but accepts a variable outer stride (leading dimension). + * This can be overridden by specifying strides. + * The type passed here must be a specialization of the Stride template, see examples below. + * + * This class provides a way to write non-template functions taking Eigen objects as parameters while limiting the number of copies. + * A Ref<> object can represent either a const expression or a l-value: + * \code + * // in-out argument: + * void foo1(Ref x); + * + * // read-only const argument: + * void foo2(const Ref& x); + * \endcode + * + * In the in-out case, the input argument must satisfy the constraints of the actual Ref<> type, otherwise a compilation issue will be triggered. + * By default, a Ref can reference any dense vector expression of float having a contiguous memory layout. + * Likewise, a Ref can reference any column-major dense matrix expression of float whose column's elements are contiguously stored with + * the possibility to have a constant space in-between each column, i.e. the inner stride must be equal to 1, but the outer stride (or leading dimension) + * can be greater than the number of rows. + * + * In the const case, if the input expression does not match the above requirement, then it is evaluated into a temporary before being passed to the function. + * Here are some examples: + * \code + * MatrixXf A; + * VectorXf a; + * foo1(a.head()); // OK + * foo1(A.col()); // OK + * foo1(A.row()); // Compilation error because here innerstride!=1 + * foo2(A.row()); // Compilation error because A.row() is a 1xN object while foo2 is expecting a Nx1 object + * foo2(A.row().transpose()); // The row is copied into a contiguous temporary + * foo2(2*a); // The expression is evaluated into a temporary + * foo2(A.col().segment(2,4)); // No temporary + * \endcode + * + * The range of inputs that can be referenced without temporary can be enlarged using the last two template parameters. + * Here is an example accepting an innerstride!=1: + * \code + * // in-out argument: + * void foo3(Ref > x); + * foo3(A.row()); // OK + * \endcode + * The downside here is that the function foo3 might be significantly slower than foo1 because it won't be able to exploit vectorization, and will involve more + * expensive address computations even if the input is contiguously stored in memory. To overcome this issue, one might propose to overload internally calling a + * template function, e.g.: + * \code + * // in the .h: + * void foo(const Ref& A); + * void foo(const Ref >& A); + * + * // in the .cpp: + * template void foo_impl(const TypeOfA& A) { + * ... // crazy code goes here + * } + * void foo(const Ref& A) { foo_impl(A); } + * void foo(const Ref >& A) { foo_impl(A); } + * \endcode + * + * + * \sa PlainObjectBase::Map(), \ref TopicStorageOrders + */ +template class Ref + : public RefBase > +{ + private: + typedef internal::traits Traits; + template + EIGEN_DEVICE_FUNC inline Ref(const PlainObjectBase& expr, + typename internal::enable_if::MatchAtCompileTime),Derived>::type* = 0); + public: + + typedef RefBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Ref) + + + #ifndef EIGEN_PARSED_BY_DOXYGEN + template + EIGEN_DEVICE_FUNC inline Ref(PlainObjectBase& expr, + typename internal::enable_if::MatchAtCompileTime),Derived>::type* = 0) + { + EIGEN_STATIC_ASSERT(bool(Traits::template match::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH); + Base::construct(expr.derived()); + } + template + EIGEN_DEVICE_FUNC inline Ref(const DenseBase& expr, + typename internal::enable_if::MatchAtCompileTime),Derived>::type* = 0) + #else + /** Implicit constructor from any dense expression */ + template + inline Ref(DenseBase& expr) + #endif + { + EIGEN_STATIC_ASSERT(bool(internal::is_lvalue::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY); + EIGEN_STATIC_ASSERT(bool(Traits::template match::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH); + EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY); + Base::construct(expr.const_cast_derived()); + } + + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Ref) + +}; + +// this is the const ref version +template class Ref + : public RefBase > +{ + typedef internal::traits Traits; + public: + + typedef RefBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Ref) + + template + EIGEN_DEVICE_FUNC inline Ref(const DenseBase& expr, + typename internal::enable_if::ScalarTypeMatch),Derived>::type* = 0) + { +// std::cout << match_helper::HasDirectAccess << "," << match_helper::OuterStrideMatch << "," << match_helper::InnerStrideMatch << "\n"; +// std::cout << int(StrideType::OuterStrideAtCompileTime) << " - " << int(Derived::OuterStrideAtCompileTime) << "\n"; +// std::cout << int(StrideType::InnerStrideAtCompileTime) << " - " << int(Derived::InnerStrideAtCompileTime) << "\n"; + construct(expr.derived(), typename Traits::template match::type()); + } + + EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) { + // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy + } + + template + EIGEN_DEVICE_FUNC inline Ref(const RefBase& other) { + construct(other.derived(), typename Traits::template match::type()); + } + + protected: + + template + EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type) + { + Base::construct(expr); + } + + template + EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type) + { + internal::call_assignment_no_alias(m_object,expr,internal::assign_op()); + Base::construct(m_object); + } + + protected: + TPlainObjectType m_object; +}; + +} // end namespace Eigen + +#endif // EIGEN_REF_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Replicate.h b/3rdparty/eigen3/Eigen/src/Core/Replicate.h new file mode 100644 index 0000000..9960ef8 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Replicate.h @@ -0,0 +1,142 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_REPLICATE_H +#define EIGEN_REPLICATE_H + +namespace Eigen { + +namespace internal { +template +struct traits > + : traits +{ + typedef typename MatrixType::Scalar Scalar; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; + typedef typename ref_selector::type MatrixTypeNested; + typedef typename remove_reference::type _MatrixTypeNested; + enum { + RowsAtCompileTime = RowFactor==Dynamic || int(MatrixType::RowsAtCompileTime)==Dynamic + ? Dynamic + : RowFactor * MatrixType::RowsAtCompileTime, + ColsAtCompileTime = ColFactor==Dynamic || int(MatrixType::ColsAtCompileTime)==Dynamic + ? Dynamic + : ColFactor * MatrixType::ColsAtCompileTime, + //FIXME we don't propagate the max sizes !!! + MaxRowsAtCompileTime = RowsAtCompileTime, + MaxColsAtCompileTime = ColsAtCompileTime, + IsRowMajor = MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1 ? 1 + : MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1 ? 0 + : (MatrixType::Flags & RowMajorBit) ? 1 : 0, + + // FIXME enable DirectAccess with negative strides? + Flags = IsRowMajor ? RowMajorBit : 0 + }; +}; +} + +/** + * \class Replicate + * \ingroup Core_Module + * + * \brief Expression of the multiple replication of a matrix or vector + * + * \tparam MatrixType the type of the object we are replicating + * \tparam RowFactor number of repetitions at compile time along the vertical direction, can be Dynamic. + * \tparam ColFactor number of repetitions at compile time along the horizontal direction, can be Dynamic. + * + * This class represents an expression of the multiple replication of a matrix or vector. + * It is the return type of DenseBase::replicate() and most of the time + * this is the only way it is used. + * + * \sa DenseBase::replicate() + */ +template class Replicate + : public internal::dense_xpr_base< Replicate >::type +{ + typedef typename internal::traits::MatrixTypeNested MatrixTypeNested; + typedef typename internal::traits::_MatrixTypeNested _MatrixTypeNested; + public: + + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Replicate) + typedef typename internal::remove_all::type NestedExpression; + + template + EIGEN_DEVICE_FUNC + inline explicit Replicate(const OriginalMatrixType& matrix) + : m_matrix(matrix), m_rowFactor(RowFactor), m_colFactor(ColFactor) + { + EIGEN_STATIC_ASSERT((internal::is_same::type,OriginalMatrixType>::value), + THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE) + eigen_assert(RowFactor!=Dynamic && ColFactor!=Dynamic); + } + + template + EIGEN_DEVICE_FUNC + inline Replicate(const OriginalMatrixType& matrix, Index rowFactor, Index colFactor) + : m_matrix(matrix), m_rowFactor(rowFactor), m_colFactor(colFactor) + { + EIGEN_STATIC_ASSERT((internal::is_same::type,OriginalMatrixType>::value), + THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE) + } + + EIGEN_DEVICE_FUNC + inline Index rows() const { return m_matrix.rows() * m_rowFactor.value(); } + EIGEN_DEVICE_FUNC + inline Index cols() const { return m_matrix.cols() * m_colFactor.value(); } + + EIGEN_DEVICE_FUNC + const _MatrixTypeNested& nestedExpression() const + { + return m_matrix; + } + + protected: + MatrixTypeNested m_matrix; + const internal::variable_if_dynamic m_rowFactor; + const internal::variable_if_dynamic m_colFactor; +}; + +/** + * \return an expression of the replication of \c *this + * + * Example: \include MatrixBase_replicate.cpp + * Output: \verbinclude MatrixBase_replicate.out + * + * \sa VectorwiseOp::replicate(), DenseBase::replicate(Index,Index), class Replicate + */ +template +template +const Replicate +DenseBase::replicate() const +{ + return Replicate(derived()); +} + +/** + * \return an expression of the replication of each column (or row) of \c *this + * + * Example: \include DirectionWise_replicate_int.cpp + * Output: \verbinclude DirectionWise_replicate_int.out + * + * \sa VectorwiseOp::replicate(), DenseBase::replicate(), class Replicate + */ +template +const typename VectorwiseOp::ReplicateReturnType +VectorwiseOp::replicate(Index factor) const +{ + return typename VectorwiseOp::ReplicateReturnType + (_expression(),Direction==Vertical?factor:1,Direction==Horizontal?factor:1); +} + +} // end namespace Eigen + +#endif // EIGEN_REPLICATE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/ReturnByValue.h b/3rdparty/eigen3/Eigen/src/Core/ReturnByValue.h new file mode 100644 index 0000000..c44b767 --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/ReturnByValue.h @@ -0,0 +1,117 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009-2010 Gael Guennebaud +// Copyright (C) 2009-2010 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_RETURNBYVALUE_H +#define EIGEN_RETURNBYVALUE_H + +namespace Eigen { + +namespace internal { + +template +struct traits > + : public traits::ReturnType> +{ + enum { + // We're disabling the DirectAccess because e.g. the constructor of + // the Block-with-DirectAccess expression requires to have a coeffRef method. + // Also, we don't want to have to implement the stride stuff. + Flags = (traits::ReturnType>::Flags + | EvalBeforeNestingBit) & ~DirectAccessBit + }; +}; + +/* The ReturnByValue object doesn't even have a coeff() method. + * So the only way that nesting it in an expression can work, is by evaluating it into a plain matrix. + * So internal::nested always gives the plain return matrix type. + * + * FIXME: I don't understand why we need this specialization: isn't this taken care of by the EvalBeforeNestingBit ?? + * Answer: EvalBeforeNestingBit should be deprecated since we have the evaluators + */ +template +struct nested_eval, n, PlainObject> +{ + typedef typename traits::ReturnType type; +}; + +} // end namespace internal + +/** \class ReturnByValue + * \ingroup Core_Module + * + */ +template class ReturnByValue + : public internal::dense_xpr_base< ReturnByValue >::type, internal::no_assignment_operator +{ + public: + typedef typename internal::traits::ReturnType ReturnType; + + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue) + + template + EIGEN_DEVICE_FUNC + inline void evalTo(Dest& dst) const + { static_cast(this)->evalTo(dst); } + EIGEN_DEVICE_FUNC inline Index rows() const { return static_cast(this)->rows(); } + EIGEN_DEVICE_FUNC inline Index cols() const { return static_cast(this)->cols(); } + +#ifndef EIGEN_PARSED_BY_DOXYGEN +#define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT + class Unusable{ + Unusable(const Unusable&) {} + Unusable& operator=(const Unusable&) {return *this;} + }; + const Unusable& coeff(Index) const { return *reinterpret_cast(this); } + const Unusable& coeff(Index,Index) const { return *reinterpret_cast(this); } + Unusable& coeffRef(Index) { return *reinterpret_cast(this); } + Unusable& coeffRef(Index,Index) { return *reinterpret_cast(this); } +#undef Unusable +#endif +}; + +template +template +Derived& DenseBase::operator=(const ReturnByValue& other) +{ + other.evalTo(derived()); + return derived(); +} + +namespace internal { + +// Expression is evaluated in a temporary; default implementation of Assignment is bypassed so that +// when a ReturnByValue expression is assigned, the evaluator is not constructed. +// TODO: Finalize port to new regime; ReturnByValue should not exist in the expression world + +template +struct evaluator > + : public evaluator::ReturnType> +{ + typedef ReturnByValue XprType; + typedef typename internal::traits::ReturnType PlainObject; + typedef evaluator Base; + + EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) + : m_result(xpr.rows(), xpr.cols()) + { + ::new (static_cast(this)) Base(m_result); + xpr.evalTo(m_result); + } + +protected: + PlainObject m_result; +}; + +} // end namespace internal + +} // end namespace Eigen + +#endif // EIGEN_RETURNBYVALUE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Reverse.h b/3rdparty/eigen3/Eigen/src/Core/Reverse.h new file mode 100644 index 0000000..0640cda --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Reverse.h @@ -0,0 +1,211 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2006-2008 Benoit Jacob +// Copyright (C) 2009 Ricard Marxer +// Copyright (C) 2009-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_REVERSE_H +#define EIGEN_REVERSE_H + +namespace Eigen { + +namespace internal { + +template +struct traits > + : traits +{ + typedef typename MatrixType::Scalar Scalar; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; + typedef typename ref_selector::type MatrixTypeNested; + typedef typename remove_reference::type _MatrixTypeNested; + enum { + RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime, + MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, + MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, + Flags = _MatrixTypeNested::Flags & (RowMajorBit | LvalueBit) + }; +}; + +template struct reverse_packet_cond +{ + static inline PacketType run(const PacketType& x) { return preverse(x); } +}; + +template struct reverse_packet_cond +{ + static inline PacketType run(const PacketType& x) { return x; } +}; + +} // end namespace internal + +/** \class Reverse + * \ingroup Core_Module + * + * \brief Expression of the reverse of a vector or matrix + * + * \tparam MatrixType the type of the object of which we are taking the reverse + * \tparam Direction defines the direction of the reverse operation, can be Vertical, Horizontal, or BothDirections + * + * This class represents an expression of the reverse of a vector. + * It is the return type of MatrixBase::reverse() and VectorwiseOp::reverse() + * and most of the time this is the only way it is used. + * + * \sa MatrixBase::reverse(), VectorwiseOp::reverse() + */ +template class Reverse + : public internal::dense_xpr_base< Reverse >::type +{ + public: + + typedef typename internal::dense_xpr_base::type Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Reverse) + typedef typename internal::remove_all::type NestedExpression; + using Base::IsRowMajor; + + protected: + enum { + PacketSize = internal::packet_traits::size, + IsColMajor = !IsRowMajor, + ReverseRow = (Direction == Vertical) || (Direction == BothDirections), + ReverseCol = (Direction == Horizontal) || (Direction == BothDirections), + OffsetRow = ReverseRow && IsColMajor ? PacketSize : 1, + OffsetCol = ReverseCol && IsRowMajor ? PacketSize : 1, + ReversePacket = (Direction == BothDirections) + || ((Direction == Vertical) && IsColMajor) + || ((Direction == Horizontal) && IsRowMajor) + }; + typedef internal::reverse_packet_cond reverse_packet; + public: + + EIGEN_DEVICE_FUNC explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { } + + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reverse) + + EIGEN_DEVICE_FUNC inline Index rows() const { return m_matrix.rows(); } + EIGEN_DEVICE_FUNC inline Index cols() const { return m_matrix.cols(); } + + EIGEN_DEVICE_FUNC inline Index innerStride() const + { + return -m_matrix.innerStride(); + } + + EIGEN_DEVICE_FUNC const typename internal::remove_all::type& + nestedExpression() const + { + return m_matrix; + } + + protected: + typename MatrixType::Nested m_matrix; +}; + +/** \returns an expression of the reverse of *this. + * + * Example: \include MatrixBase_reverse.cpp + * Output: \verbinclude MatrixBase_reverse.out + * + */ +template +inline typename DenseBase::ReverseReturnType +DenseBase::reverse() +{ + return ReverseReturnType(derived()); +} + + +//reverse const overload moved DenseBase.h due to a CUDA compiler bug + +/** This is the "in place" version of reverse: it reverses \c *this. + * + * In most cases it is probably better to simply use the reversed expression + * of a matrix. However, when reversing the matrix data itself is really needed, + * then this "in-place" version is probably the right choice because it provides + * the following additional benefits: + * - less error prone: doing the same operation with .reverse() requires special care: + * \code m = m.reverse().eval(); \endcode + * - this API enables reverse operations without the need for a temporary + * - it allows future optimizations (cache friendliness, etc.) + * + * \sa VectorwiseOp::reverseInPlace(), reverse() */ +template +inline void DenseBase::reverseInPlace() +{ + if(cols()>rows()) + { + Index half = cols()/2; + leftCols(half).swap(rightCols(half).reverse()); + if((cols()%2)==1) + { + Index half2 = rows()/2; + col(half).head(half2).swap(col(half).tail(half2).reverse()); + } + } + else + { + Index half = rows()/2; + topRows(half).swap(bottomRows(half).reverse()); + if((rows()%2)==1) + { + Index half2 = cols()/2; + row(half).head(half2).swap(row(half).tail(half2).reverse()); + } + } +} + +namespace internal { + +template +struct vectorwise_reverse_inplace_impl; + +template<> +struct vectorwise_reverse_inplace_impl +{ + template + static void run(ExpressionType &xpr) + { + Index half = xpr.rows()/2; + xpr.topRows(half).swap(xpr.bottomRows(half).colwise().reverse()); + } +}; + +template<> +struct vectorwise_reverse_inplace_impl +{ + template + static void run(ExpressionType &xpr) + { + Index half = xpr.cols()/2; + xpr.leftCols(half).swap(xpr.rightCols(half).rowwise().reverse()); + } +}; + +} // end namespace internal + +/** This is the "in place" version of VectorwiseOp::reverse: it reverses each column or row of \c *this. + * + * In most cases it is probably better to simply use the reversed expression + * of a matrix. However, when reversing the matrix data itself is really needed, + * then this "in-place" version is probably the right choice because it provides + * the following additional benefits: + * - less error prone: doing the same operation with .reverse() requires special care: + * \code m = m.reverse().eval(); \endcode + * - this API enables reverse operations without the need for a temporary + * + * \sa DenseBase::reverseInPlace(), reverse() */ +template +void VectorwiseOp::reverseInPlace() +{ + internal::vectorwise_reverse_inplace_impl::run(_expression().const_cast_derived()); +} + +} // end namespace Eigen + +#endif // EIGEN_REVERSE_H diff --git a/3rdparty/eigen3/Eigen/src/Core/Select.h b/3rdparty/eigen3/Eigen/src/Core/Select.h new file mode 100644 index 0000000..79eec1b --- /dev/null +++ b/3rdparty/eigen3/Eigen/src/Core/Select.h @@ -0,0 +1,162 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2010 Gael Guennebaud +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_SELECT_H +#define EIGEN_SELECT_H + +namespace Eigen { + +/** \class Select + * \ingroup Core_Module + * + * \brief Expression of a coefficient wise version of the C++ ternary operator ?: + * + * \param ConditionMatrixType the type of the \em condition expression which must be a boolean matrix + * \param ThenMatrixType the type of the \em then expression + * \param ElseMatrixType the type of the \em else expression + * + * This class represents an expression of a coefficient wise version of the C++ ternary operator ?:. + * It is the return type of DenseBase::select() and most of the time this is the only way it is used. + * + * \sa DenseBase::select(const DenseBase&, const DenseBase&) const + */ + +namespace internal { +template +struct traits > + : traits +{ + typedef typename traits::Scalar Scalar; + typedef Dense StorageKind; + typedef typename traits::XprKind XprKind; + typedef typename ConditionMatrixType::Nested ConditionMatrixNested; + typedef typename ThenMatrixType::Nested ThenMatrixNested; + typedef typename ElseMatrixType::Nested ElseMatrixNested; + enum { + RowsAtCompileTime = ConditionMatrixType::RowsAtCompileTime, + ColsAtCompileTime = ConditionMatrixType::ColsAtCompileTime, + MaxRowsAtCompileTime = ConditionMatrixType::MaxRowsAtCompileTime, + MaxColsAtCompileTime = ConditionMatrixType::MaxColsAtCompileTime, + Flags = (unsigned int)ThenMatrixType::Flags & ElseMatrixType::Flags & RowMajorBit + }; +}; +} + +template +class Select : public internal::dense_xpr_base< Select >::type, + internal::no_assignment_operator +{ + public: + + typedef typename internal::dense_xpr_base